sqlglot.generator

   1from __future__ import annotations
   2
   3import logging
   4import re
   5import typing as t
   6from collections import defaultdict
   7from functools import reduce, wraps
   8
   9from sqlglot import exp
  10from sqlglot.errors import ErrorLevel, UnsupportedError, concat_messages
  11from sqlglot.helper import apply_index_offset, csv, name_sequence, seq_get
  12from sqlglot.jsonpath import ALL_JSON_PATH_PARTS, JSON_PATH_PART_TRANSFORMS
  13from sqlglot.time import format_time
  14from sqlglot.tokens import TokenType
  15
  16if t.TYPE_CHECKING:
  17    from sqlglot._typing import E
  18    from sqlglot.dialects.dialect import DialectType
  19
  20    G = t.TypeVar("G", bound="Generator")
  21    GeneratorMethod = t.Callable[[G, E], str]
  22
  23logger = logging.getLogger("sqlglot")
  24
  25ESCAPED_UNICODE_RE = re.compile(r"\\(\d+)")
  26UNSUPPORTED_TEMPLATE = "Argument '{}' is not supported for expression '{}' when targeting {}."
  27
  28
  29def unsupported_args(
  30    *args: t.Union[str, t.Tuple[str, str]],
  31) -> t.Callable[[GeneratorMethod], GeneratorMethod]:
  32    """
  33    Decorator that can be used to mark certain args of an `Expression` subclass as unsupported.
  34    It expects a sequence of argument names or pairs of the form (argument_name, diagnostic_msg).
  35    """
  36    diagnostic_by_arg: t.Dict[str, t.Optional[str]] = {}
  37    for arg in args:
  38        if isinstance(arg, str):
  39            diagnostic_by_arg[arg] = None
  40        else:
  41            diagnostic_by_arg[arg[0]] = arg[1]
  42
  43    def decorator(func: GeneratorMethod) -> GeneratorMethod:
  44        @wraps(func)
  45        def _func(generator: G, expression: E) -> str:
  46            expression_name = expression.__class__.__name__
  47            dialect_name = generator.dialect.__class__.__name__
  48
  49            for arg_name, diagnostic in diagnostic_by_arg.items():
  50                if expression.args.get(arg_name):
  51                    diagnostic = diagnostic or UNSUPPORTED_TEMPLATE.format(
  52                        arg_name, expression_name, dialect_name
  53                    )
  54                    generator.unsupported(diagnostic)
  55
  56            return func(generator, expression)
  57
  58        return _func
  59
  60    return decorator
  61
  62
  63class _Generator(type):
  64    def __new__(cls, clsname, bases, attrs):
  65        klass = super().__new__(cls, clsname, bases, attrs)
  66
  67        # Remove transforms that correspond to unsupported JSONPathPart expressions
  68        for part in ALL_JSON_PATH_PARTS - klass.SUPPORTED_JSON_PATH_PARTS:
  69            klass.TRANSFORMS.pop(part, None)
  70
  71        return klass
  72
  73
  74class Generator(metaclass=_Generator):
  75    """
  76    Generator converts a given syntax tree to the corresponding SQL string.
  77
  78    Args:
  79        pretty: Whether to format the produced SQL string.
  80            Default: False.
  81        identify: Determines when an identifier should be quoted. Possible values are:
  82            False (default): Never quote, except in cases where it's mandatory by the dialect.
  83            True or 'always': Always quote.
  84            'safe': Only quote identifiers that are case insensitive.
  85        normalize: Whether to normalize identifiers to lowercase.
  86            Default: False.
  87        pad: The pad size in a formatted string. For example, this affects the indentation of
  88            a projection in a query, relative to its nesting level.
  89            Default: 2.
  90        indent: The indentation size in a formatted string. For example, this affects the
  91            indentation of subqueries and filters under a `WHERE` clause.
  92            Default: 2.
  93        normalize_functions: How to normalize function names. Possible values are:
  94            "upper" or True (default): Convert names to uppercase.
  95            "lower": Convert names to lowercase.
  96            False: Disables function name normalization.
  97        unsupported_level: Determines the generator's behavior when it encounters unsupported expressions.
  98            Default ErrorLevel.WARN.
  99        max_unsupported: Maximum number of unsupported messages to include in a raised UnsupportedError.
 100            This is only relevant if unsupported_level is ErrorLevel.RAISE.
 101            Default: 3
 102        leading_comma: Whether the comma is leading or trailing in select expressions.
 103            This is only relevant when generating in pretty mode.
 104            Default: False
 105        max_text_width: The max number of characters in a segment before creating new lines in pretty mode.
 106            The default is on the smaller end because the length only represents a segment and not the true
 107            line length.
 108            Default: 80
 109        comments: Whether to preserve comments in the output SQL code.
 110            Default: True
 111    """
 112
 113    TRANSFORMS: t.Dict[t.Type[exp.Expression], t.Callable[..., str]] = {
 114        **JSON_PATH_PART_TRANSFORMS,
 115        exp.AllowedValuesProperty: lambda self,
 116        e: f"ALLOWED_VALUES {self.expressions(e, flat=True)}",
 117        exp.AnalyzeColumns: lambda self, e: self.sql(e, "this"),
 118        exp.AnalyzeWith: lambda self, e: self.expressions(e, prefix="WITH ", sep=" "),
 119        exp.ArrayContainsAll: lambda self, e: self.binary(e, "@>"),
 120        exp.ArrayOverlaps: lambda self, e: self.binary(e, "&&"),
 121        exp.AutoRefreshProperty: lambda self, e: f"AUTO REFRESH {self.sql(e, 'this')}",
 122        exp.BackupProperty: lambda self, e: f"BACKUP {self.sql(e, 'this')}",
 123        exp.CaseSpecificColumnConstraint: lambda _,
 124        e: f"{'NOT ' if e.args.get('not_') else ''}CASESPECIFIC",
 125        exp.Ceil: lambda self, e: self.ceil_floor(e),
 126        exp.CharacterSetColumnConstraint: lambda self, e: f"CHARACTER SET {self.sql(e, 'this')}",
 127        exp.CharacterSetProperty: lambda self,
 128        e: f"{'DEFAULT ' if e.args.get('default') else ''}CHARACTER SET={self.sql(e, 'this')}",
 129        exp.ClusteredColumnConstraint: lambda self,
 130        e: f"CLUSTERED ({self.expressions(e, 'this', indent=False)})",
 131        exp.CollateColumnConstraint: lambda self, e: f"COLLATE {self.sql(e, 'this')}",
 132        exp.CommentColumnConstraint: lambda self, e: f"COMMENT {self.sql(e, 'this')}",
 133        exp.ConnectByRoot: lambda self, e: f"CONNECT_BY_ROOT {self.sql(e, 'this')}",
 134        exp.ConvertToCharset: lambda self, e: self.func(
 135            "CONVERT", e.this, e.args["dest"], e.args.get("source")
 136        ),
 137        exp.CopyGrantsProperty: lambda *_: "COPY GRANTS",
 138        exp.CredentialsProperty: lambda self,
 139        e: f"CREDENTIALS=({self.expressions(e, 'expressions', sep=' ')})",
 140        exp.DateFormatColumnConstraint: lambda self, e: f"FORMAT {self.sql(e, 'this')}",
 141        exp.DefaultColumnConstraint: lambda self, e: f"DEFAULT {self.sql(e, 'this')}",
 142        exp.DynamicProperty: lambda *_: "DYNAMIC",
 143        exp.EmptyProperty: lambda *_: "EMPTY",
 144        exp.EncodeColumnConstraint: lambda self, e: f"ENCODE {self.sql(e, 'this')}",
 145        exp.EnviromentProperty: lambda self, e: f"ENVIRONMENT ({self.expressions(e, flat=True)})",
 146        exp.EphemeralColumnConstraint: lambda self,
 147        e: f"EPHEMERAL{(' ' + self.sql(e, 'this')) if e.this else ''}",
 148        exp.ExcludeColumnConstraint: lambda self, e: f"EXCLUDE {self.sql(e, 'this').lstrip()}",
 149        exp.ExecuteAsProperty: lambda self, e: self.naked_property(e),
 150        exp.Except: lambda self, e: self.set_operations(e),
 151        exp.ExternalProperty: lambda *_: "EXTERNAL",
 152        exp.Floor: lambda self, e: self.ceil_floor(e),
 153        exp.Get: lambda self, e: self.get_put_sql(e),
 154        exp.GlobalProperty: lambda *_: "GLOBAL",
 155        exp.HeapProperty: lambda *_: "HEAP",
 156        exp.IcebergProperty: lambda *_: "ICEBERG",
 157        exp.InheritsProperty: lambda self, e: f"INHERITS ({self.expressions(e, flat=True)})",
 158        exp.InlineLengthColumnConstraint: lambda self, e: f"INLINE LENGTH {self.sql(e, 'this')}",
 159        exp.InputModelProperty: lambda self, e: f"INPUT{self.sql(e, 'this')}",
 160        exp.Intersect: lambda self, e: self.set_operations(e),
 161        exp.IntervalSpan: lambda self, e: f"{self.sql(e, 'this')} TO {self.sql(e, 'expression')}",
 162        exp.Int64: lambda self, e: self.sql(exp.cast(e.this, exp.DataType.Type.BIGINT)),
 163        exp.LanguageProperty: lambda self, e: self.naked_property(e),
 164        exp.LocationProperty: lambda self, e: self.naked_property(e),
 165        exp.LogProperty: lambda _, e: f"{'NO ' if e.args.get('no') else ''}LOG",
 166        exp.MaterializedProperty: lambda *_: "MATERIALIZED",
 167        exp.NonClusteredColumnConstraint: lambda self,
 168        e: f"NONCLUSTERED ({self.expressions(e, 'this', indent=False)})",
 169        exp.NoPrimaryIndexProperty: lambda *_: "NO PRIMARY INDEX",
 170        exp.NotForReplicationColumnConstraint: lambda *_: "NOT FOR REPLICATION",
 171        exp.OnCommitProperty: lambda _,
 172        e: f"ON COMMIT {'DELETE' if e.args.get('delete') else 'PRESERVE'} ROWS",
 173        exp.OnProperty: lambda self, e: f"ON {self.sql(e, 'this')}",
 174        exp.OnUpdateColumnConstraint: lambda self, e: f"ON UPDATE {self.sql(e, 'this')}",
 175        exp.Operator: lambda self, e: self.binary(e, ""),  # The operator is produced in `binary`
 176        exp.OutputModelProperty: lambda self, e: f"OUTPUT{self.sql(e, 'this')}",
 177        exp.PathColumnConstraint: lambda self, e: f"PATH {self.sql(e, 'this')}",
 178        exp.PartitionedByBucket: lambda self, e: self.func("BUCKET", e.this, e.expression),
 179        exp.PartitionByTruncate: lambda self, e: self.func("TRUNCATE", e.this, e.expression),
 180        exp.PivotAny: lambda self, e: f"ANY{self.sql(e, 'this')}",
 181        exp.PositionalColumn: lambda self, e: f"#{self.sql(e, 'this')}",
 182        exp.ProjectionPolicyColumnConstraint: lambda self,
 183        e: f"PROJECTION POLICY {self.sql(e, 'this')}",
 184        exp.Put: lambda self, e: self.get_put_sql(e),
 185        exp.RemoteWithConnectionModelProperty: lambda self,
 186        e: f"REMOTE WITH CONNECTION {self.sql(e, 'this')}",
 187        exp.ReturnsProperty: lambda self, e: (
 188            "RETURNS NULL ON NULL INPUT" if e.args.get("null") else self.naked_property(e)
 189        ),
 190        exp.SampleProperty: lambda self, e: f"SAMPLE BY {self.sql(e, 'this')}",
 191        exp.SecureProperty: lambda *_: "SECURE",
 192        exp.SecurityProperty: lambda self, e: f"SECURITY {self.sql(e, 'this')}",
 193        exp.SetConfigProperty: lambda self, e: self.sql(e, "this"),
 194        exp.SetProperty: lambda _, e: f"{'MULTI' if e.args.get('multi') else ''}SET",
 195        exp.SettingsProperty: lambda self, e: f"SETTINGS{self.seg('')}{(self.expressions(e))}",
 196        exp.SharingProperty: lambda self, e: f"SHARING={self.sql(e, 'this')}",
 197        exp.SqlReadWriteProperty: lambda _, e: e.name,
 198        exp.SqlSecurityProperty: lambda _,
 199        e: f"SQL SECURITY {'DEFINER' if e.args.get('definer') else 'INVOKER'}",
 200        exp.StabilityProperty: lambda _, e: e.name,
 201        exp.Stream: lambda self, e: f"STREAM {self.sql(e, 'this')}",
 202        exp.StreamingTableProperty: lambda *_: "STREAMING",
 203        exp.StrictProperty: lambda *_: "STRICT",
 204        exp.SwapTable: lambda self, e: f"SWAP WITH {self.sql(e, 'this')}",
 205        exp.TableColumn: lambda self, e: self.sql(e.this),
 206        exp.Tags: lambda self, e: f"TAG ({self.expressions(e, flat=True)})",
 207        exp.TemporaryProperty: lambda *_: "TEMPORARY",
 208        exp.TitleColumnConstraint: lambda self, e: f"TITLE {self.sql(e, 'this')}",
 209        exp.ToMap: lambda self, e: f"MAP {self.sql(e, 'this')}",
 210        exp.ToTableProperty: lambda self, e: f"TO {self.sql(e.this)}",
 211        exp.TransformModelProperty: lambda self, e: self.func("TRANSFORM", *e.expressions),
 212        exp.TransientProperty: lambda *_: "TRANSIENT",
 213        exp.Union: lambda self, e: self.set_operations(e),
 214        exp.UnloggedProperty: lambda *_: "UNLOGGED",
 215        exp.UsingTemplateProperty: lambda self, e: f"USING TEMPLATE {self.sql(e, 'this')}",
 216        exp.UsingData: lambda self, e: f"USING DATA {self.sql(e, 'this')}",
 217        exp.Uuid: lambda *_: "UUID()",
 218        exp.UppercaseColumnConstraint: lambda *_: "UPPERCASE",
 219        exp.VarMap: lambda self, e: self.func("MAP", e.args["keys"], e.args["values"]),
 220        exp.ViewAttributeProperty: lambda self, e: f"WITH {self.sql(e, 'this')}",
 221        exp.VolatileProperty: lambda *_: "VOLATILE",
 222        exp.WithJournalTableProperty: lambda self, e: f"WITH JOURNAL TABLE={self.sql(e, 'this')}",
 223        exp.WithProcedureOptions: lambda self, e: f"WITH {self.expressions(e, flat=True)}",
 224        exp.WithSchemaBindingProperty: lambda self, e: f"WITH SCHEMA {self.sql(e, 'this')}",
 225        exp.WithOperator: lambda self, e: f"{self.sql(e, 'this')} WITH {self.sql(e, 'op')}",
 226        exp.ForceProperty: lambda *_: "FORCE",
 227    }
 228
 229    # Whether null ordering is supported in order by
 230    # True: Full Support, None: No support, False: No support for certain cases
 231    # such as window specifications, aggregate functions etc
 232    NULL_ORDERING_SUPPORTED: t.Optional[bool] = True
 233
 234    # Whether ignore nulls is inside the agg or outside.
 235    # FIRST(x IGNORE NULLS) OVER vs FIRST (x) IGNORE NULLS OVER
 236    IGNORE_NULLS_IN_FUNC = False
 237
 238    # Whether locking reads (i.e. SELECT ... FOR UPDATE/SHARE) are supported
 239    LOCKING_READS_SUPPORTED = False
 240
 241    # Whether the EXCEPT and INTERSECT operations can return duplicates
 242    EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE = True
 243
 244    # Wrap derived values in parens, usually standard but spark doesn't support it
 245    WRAP_DERIVED_VALUES = True
 246
 247    # Whether create function uses an AS before the RETURN
 248    CREATE_FUNCTION_RETURN_AS = True
 249
 250    # Whether MERGE ... WHEN MATCHED BY SOURCE is allowed
 251    MATCHED_BY_SOURCE = True
 252
 253    # Whether the INTERVAL expression works only with values like '1 day'
 254    SINGLE_STRING_INTERVAL = False
 255
 256    # Whether the plural form of date parts like day (i.e. "days") is supported in INTERVALs
 257    INTERVAL_ALLOWS_PLURAL_FORM = True
 258
 259    # Whether limit and fetch are supported (possible values: "ALL", "LIMIT", "FETCH")
 260    LIMIT_FETCH = "ALL"
 261
 262    # Whether limit and fetch allows expresions or just limits
 263    LIMIT_ONLY_LITERALS = False
 264
 265    # Whether a table is allowed to be renamed with a db
 266    RENAME_TABLE_WITH_DB = True
 267
 268    # The separator for grouping sets and rollups
 269    GROUPINGS_SEP = ","
 270
 271    # The string used for creating an index on a table
 272    INDEX_ON = "ON"
 273
 274    # Whether join hints should be generated
 275    JOIN_HINTS = True
 276
 277    # Whether table hints should be generated
 278    TABLE_HINTS = True
 279
 280    # Whether query hints should be generated
 281    QUERY_HINTS = True
 282
 283    # What kind of separator to use for query hints
 284    QUERY_HINT_SEP = ", "
 285
 286    # Whether comparing against booleans (e.g. x IS TRUE) is supported
 287    IS_BOOL_ALLOWED = True
 288
 289    # Whether to include the "SET" keyword in the "INSERT ... ON DUPLICATE KEY UPDATE" statement
 290    DUPLICATE_KEY_UPDATE_WITH_SET = True
 291
 292    # Whether to generate the limit as TOP <value> instead of LIMIT <value>
 293    LIMIT_IS_TOP = False
 294
 295    # Whether to generate INSERT INTO ... RETURNING or INSERT INTO RETURNING ...
 296    RETURNING_END = True
 297
 298    # Whether to generate an unquoted value for EXTRACT's date part argument
 299    EXTRACT_ALLOWS_QUOTES = True
 300
 301    # Whether TIMETZ / TIMESTAMPTZ will be generated using the "WITH TIME ZONE" syntax
 302    TZ_TO_WITH_TIME_ZONE = False
 303
 304    # Whether the NVL2 function is supported
 305    NVL2_SUPPORTED = True
 306
 307    # https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax
 308    SELECT_KINDS: t.Tuple[str, ...] = ("STRUCT", "VALUE")
 309
 310    # Whether VALUES statements can be used as derived tables.
 311    # MySQL 5 and Redshift do not allow this, so when False, it will convert
 312    # SELECT * VALUES into SELECT UNION
 313    VALUES_AS_TABLE = True
 314
 315    # Whether the word COLUMN is included when adding a column with ALTER TABLE
 316    ALTER_TABLE_INCLUDE_COLUMN_KEYWORD = True
 317
 318    # UNNEST WITH ORDINALITY (presto) instead of UNNEST WITH OFFSET (bigquery)
 319    UNNEST_WITH_ORDINALITY = True
 320
 321    # Whether FILTER (WHERE cond) can be used for conditional aggregation
 322    AGGREGATE_FILTER_SUPPORTED = True
 323
 324    # Whether JOIN sides (LEFT, RIGHT) are supported in conjunction with SEMI/ANTI join kinds
 325    SEMI_ANTI_JOIN_WITH_SIDE = True
 326
 327    # Whether to include the type of a computed column in the CREATE DDL
 328    COMPUTED_COLUMN_WITH_TYPE = True
 329
 330    # Whether CREATE TABLE .. COPY .. is supported. False means we'll generate CLONE instead of COPY
 331    SUPPORTS_TABLE_COPY = True
 332
 333    # Whether parentheses are required around the table sample's expression
 334    TABLESAMPLE_REQUIRES_PARENS = True
 335
 336    # Whether a table sample clause's size needs to be followed by the ROWS keyword
 337    TABLESAMPLE_SIZE_IS_ROWS = True
 338
 339    # The keyword(s) to use when generating a sample clause
 340    TABLESAMPLE_KEYWORDS = "TABLESAMPLE"
 341
 342    # Whether the TABLESAMPLE clause supports a method name, like BERNOULLI
 343    TABLESAMPLE_WITH_METHOD = True
 344
 345    # The keyword to use when specifying the seed of a sample clause
 346    TABLESAMPLE_SEED_KEYWORD = "SEED"
 347
 348    # Whether COLLATE is a function instead of a binary operator
 349    COLLATE_IS_FUNC = False
 350
 351    # Whether data types support additional specifiers like e.g. CHAR or BYTE (oracle)
 352    DATA_TYPE_SPECIFIERS_ALLOWED = False
 353
 354    # Whether conditions require booleans WHERE x = 0 vs WHERE x
 355    ENSURE_BOOLS = False
 356
 357    # Whether the "RECURSIVE" keyword is required when defining recursive CTEs
 358    CTE_RECURSIVE_KEYWORD_REQUIRED = True
 359
 360    # Whether CONCAT requires >1 arguments
 361    SUPPORTS_SINGLE_ARG_CONCAT = True
 362
 363    # Whether LAST_DAY function supports a date part argument
 364    LAST_DAY_SUPPORTS_DATE_PART = True
 365
 366    # Whether named columns are allowed in table aliases
 367    SUPPORTS_TABLE_ALIAS_COLUMNS = True
 368
 369    # Whether UNPIVOT aliases are Identifiers (False means they're Literals)
 370    UNPIVOT_ALIASES_ARE_IDENTIFIERS = True
 371
 372    # What delimiter to use for separating JSON key/value pairs
 373    JSON_KEY_VALUE_PAIR_SEP = ":"
 374
 375    # INSERT OVERWRITE TABLE x override
 376    INSERT_OVERWRITE = " OVERWRITE TABLE"
 377
 378    # Whether the SELECT .. INTO syntax is used instead of CTAS
 379    SUPPORTS_SELECT_INTO = False
 380
 381    # Whether UNLOGGED tables can be created
 382    SUPPORTS_UNLOGGED_TABLES = False
 383
 384    # Whether the CREATE TABLE LIKE statement is supported
 385    SUPPORTS_CREATE_TABLE_LIKE = True
 386
 387    # Whether the LikeProperty needs to be specified inside of the schema clause
 388    LIKE_PROPERTY_INSIDE_SCHEMA = False
 389
 390    # Whether DISTINCT can be followed by multiple args in an AggFunc. If not, it will be
 391    # transpiled into a series of CASE-WHEN-ELSE, ultimately using a tuple conseisting of the args
 392    MULTI_ARG_DISTINCT = True
 393
 394    # Whether the JSON extraction operators expect a value of type JSON
 395    JSON_TYPE_REQUIRED_FOR_EXTRACTION = False
 396
 397    # Whether bracketed keys like ["foo"] are supported in JSON paths
 398    JSON_PATH_BRACKETED_KEY_SUPPORTED = True
 399
 400    # Whether to escape keys using single quotes in JSON paths
 401    JSON_PATH_SINGLE_QUOTE_ESCAPE = False
 402
 403    # The JSONPathPart expressions supported by this dialect
 404    SUPPORTED_JSON_PATH_PARTS = ALL_JSON_PATH_PARTS.copy()
 405
 406    # Whether any(f(x) for x in array) can be implemented by this dialect
 407    CAN_IMPLEMENT_ARRAY_ANY = False
 408
 409    # Whether the function TO_NUMBER is supported
 410    SUPPORTS_TO_NUMBER = True
 411
 412    # Whether EXCLUDE in window specification is supported
 413    SUPPORTS_WINDOW_EXCLUDE = False
 414
 415    # Whether or not set op modifiers apply to the outer set op or select.
 416    # SELECT * FROM x UNION SELECT * FROM y LIMIT 1
 417    # True means limit 1 happens after the set op, False means it it happens on y.
 418    SET_OP_MODIFIERS = True
 419
 420    # Whether parameters from COPY statement are wrapped in parentheses
 421    COPY_PARAMS_ARE_WRAPPED = True
 422
 423    # Whether values of params are set with "=" token or empty space
 424    COPY_PARAMS_EQ_REQUIRED = False
 425
 426    # Whether COPY statement has INTO keyword
 427    COPY_HAS_INTO_KEYWORD = True
 428
 429    # Whether the conditional TRY(expression) function is supported
 430    TRY_SUPPORTED = True
 431
 432    # Whether the UESCAPE syntax in unicode strings is supported
 433    SUPPORTS_UESCAPE = True
 434
 435    # The keyword to use when generating a star projection with excluded columns
 436    STAR_EXCEPT = "EXCEPT"
 437
 438    # The HEX function name
 439    HEX_FUNC = "HEX"
 440
 441    # The keywords to use when prefixing & separating WITH based properties
 442    WITH_PROPERTIES_PREFIX = "WITH"
 443
 444    # Whether to quote the generated expression of exp.JsonPath
 445    QUOTE_JSON_PATH = True
 446
 447    # Whether the text pattern/fill (3rd) parameter of RPAD()/LPAD() is optional (defaults to space)
 448    PAD_FILL_PATTERN_IS_REQUIRED = False
 449
 450    # Whether a projection can explode into multiple rows, e.g. by unnesting an array.
 451    SUPPORTS_EXPLODING_PROJECTIONS = True
 452
 453    # Whether ARRAY_CONCAT can be generated with varlen args or if it should be reduced to 2-arg version
 454    ARRAY_CONCAT_IS_VAR_LEN = True
 455
 456    # Whether CONVERT_TIMEZONE() is supported; if not, it will be generated as exp.AtTimeZone
 457    SUPPORTS_CONVERT_TIMEZONE = False
 458
 459    # Whether MEDIAN(expr) is supported; if not, it will be generated as PERCENTILE_CONT(expr, 0.5)
 460    SUPPORTS_MEDIAN = True
 461
 462    # Whether UNIX_SECONDS(timestamp) is supported
 463    SUPPORTS_UNIX_SECONDS = False
 464
 465    # Whether to wrap <props> in `AlterSet`, e.g., ALTER ... SET (<props>)
 466    ALTER_SET_WRAPPED = False
 467
 468    # Whether to normalize the date parts in EXTRACT(<date_part> FROM <expr>) into a common representation
 469    # For instance, to extract the day of week in ISO semantics, one can use ISODOW, DAYOFWEEKISO etc depending on the dialect.
 470    # TODO: The normalization should be done by default once we've tested it across all dialects.
 471    NORMALIZE_EXTRACT_DATE_PARTS = False
 472
 473    # The name to generate for the JSONPath expression. If `None`, only `this` will be generated
 474    PARSE_JSON_NAME: t.Optional[str] = "PARSE_JSON"
 475
 476    # The function name of the exp.ArraySize expression
 477    ARRAY_SIZE_NAME: str = "ARRAY_LENGTH"
 478
 479    # The syntax to use when altering the type of a column
 480    ALTER_SET_TYPE = "SET DATA TYPE"
 481
 482    # Whether exp.ArraySize should generate the dimension arg too (valid for Postgres & DuckDB)
 483    # None -> Doesn't support it at all
 484    # False (DuckDB) -> Has backwards-compatible support, but preferably generated without
 485    # True (Postgres) -> Explicitly requires it
 486    ARRAY_SIZE_DIM_REQUIRED: t.Optional[bool] = None
 487
 488    # Whether a multi-argument DECODE(...) function is supported. If not, a CASE expression is generated
 489    SUPPORTS_DECODE_CASE = True
 490
 491    # Whether SYMMETRIC and ASYMMETRIC flags are supported with BETWEEN expression
 492    SUPPORTS_BETWEEN_FLAGS = False
 493
 494    TYPE_MAPPING = {
 495        exp.DataType.Type.DATETIME2: "TIMESTAMP",
 496        exp.DataType.Type.NCHAR: "CHAR",
 497        exp.DataType.Type.NVARCHAR: "VARCHAR",
 498        exp.DataType.Type.MEDIUMTEXT: "TEXT",
 499        exp.DataType.Type.LONGTEXT: "TEXT",
 500        exp.DataType.Type.TINYTEXT: "TEXT",
 501        exp.DataType.Type.BLOB: "VARBINARY",
 502        exp.DataType.Type.MEDIUMBLOB: "BLOB",
 503        exp.DataType.Type.LONGBLOB: "BLOB",
 504        exp.DataType.Type.TINYBLOB: "BLOB",
 505        exp.DataType.Type.INET: "INET",
 506        exp.DataType.Type.ROWVERSION: "VARBINARY",
 507        exp.DataType.Type.SMALLDATETIME: "TIMESTAMP",
 508    }
 509
 510    TIME_PART_SINGULARS = {
 511        "MICROSECONDS": "MICROSECOND",
 512        "SECONDS": "SECOND",
 513        "MINUTES": "MINUTE",
 514        "HOURS": "HOUR",
 515        "DAYS": "DAY",
 516        "WEEKS": "WEEK",
 517        "MONTHS": "MONTH",
 518        "QUARTERS": "QUARTER",
 519        "YEARS": "YEAR",
 520    }
 521
 522    AFTER_HAVING_MODIFIER_TRANSFORMS = {
 523        "cluster": lambda self, e: self.sql(e, "cluster"),
 524        "distribute": lambda self, e: self.sql(e, "distribute"),
 525        "sort": lambda self, e: self.sql(e, "sort"),
 526        "windows": lambda self, e: (
 527            self.seg("WINDOW ") + self.expressions(e, key="windows", flat=True)
 528            if e.args.get("windows")
 529            else ""
 530        ),
 531        "qualify": lambda self, e: self.sql(e, "qualify"),
 532    }
 533
 534    TOKEN_MAPPING: t.Dict[TokenType, str] = {}
 535
 536    STRUCT_DELIMITER = ("<", ">")
 537
 538    PARAMETER_TOKEN = "@"
 539    NAMED_PLACEHOLDER_TOKEN = ":"
 540
 541    EXPRESSION_PRECEDES_PROPERTIES_CREATABLES: t.Set[str] = set()
 542
 543    PROPERTIES_LOCATION = {
 544        exp.AllowedValuesProperty: exp.Properties.Location.POST_SCHEMA,
 545        exp.AlgorithmProperty: exp.Properties.Location.POST_CREATE,
 546        exp.AutoIncrementProperty: exp.Properties.Location.POST_SCHEMA,
 547        exp.AutoRefreshProperty: exp.Properties.Location.POST_SCHEMA,
 548        exp.BackupProperty: exp.Properties.Location.POST_SCHEMA,
 549        exp.BlockCompressionProperty: exp.Properties.Location.POST_NAME,
 550        exp.CharacterSetProperty: exp.Properties.Location.POST_SCHEMA,
 551        exp.ChecksumProperty: exp.Properties.Location.POST_NAME,
 552        exp.CollateProperty: exp.Properties.Location.POST_SCHEMA,
 553        exp.CopyGrantsProperty: exp.Properties.Location.POST_SCHEMA,
 554        exp.Cluster: exp.Properties.Location.POST_SCHEMA,
 555        exp.ClusteredByProperty: exp.Properties.Location.POST_SCHEMA,
 556        exp.DistributedByProperty: exp.Properties.Location.POST_SCHEMA,
 557        exp.DuplicateKeyProperty: exp.Properties.Location.POST_SCHEMA,
 558        exp.DataBlocksizeProperty: exp.Properties.Location.POST_NAME,
 559        exp.DataDeletionProperty: exp.Properties.Location.POST_SCHEMA,
 560        exp.DefinerProperty: exp.Properties.Location.POST_CREATE,
 561        exp.DictRange: exp.Properties.Location.POST_SCHEMA,
 562        exp.DictProperty: exp.Properties.Location.POST_SCHEMA,
 563        exp.DynamicProperty: exp.Properties.Location.POST_CREATE,
 564        exp.DistKeyProperty: exp.Properties.Location.POST_SCHEMA,
 565        exp.DistStyleProperty: exp.Properties.Location.POST_SCHEMA,
 566        exp.EmptyProperty: exp.Properties.Location.POST_SCHEMA,
 567        exp.EncodeProperty: exp.Properties.Location.POST_EXPRESSION,
 568        exp.EngineProperty: exp.Properties.Location.POST_SCHEMA,
 569        exp.EnviromentProperty: exp.Properties.Location.POST_SCHEMA,
 570        exp.ExecuteAsProperty: exp.Properties.Location.POST_SCHEMA,
 571        exp.ExternalProperty: exp.Properties.Location.POST_CREATE,
 572        exp.FallbackProperty: exp.Properties.Location.POST_NAME,
 573        exp.FileFormatProperty: exp.Properties.Location.POST_WITH,
 574        exp.FreespaceProperty: exp.Properties.Location.POST_NAME,
 575        exp.GlobalProperty: exp.Properties.Location.POST_CREATE,
 576        exp.HeapProperty: exp.Properties.Location.POST_WITH,
 577        exp.InheritsProperty: exp.Properties.Location.POST_SCHEMA,
 578        exp.IcebergProperty: exp.Properties.Location.POST_CREATE,
 579        exp.IncludeProperty: exp.Properties.Location.POST_SCHEMA,
 580        exp.InputModelProperty: exp.Properties.Location.POST_SCHEMA,
 581        exp.IsolatedLoadingProperty: exp.Properties.Location.POST_NAME,
 582        exp.JournalProperty: exp.Properties.Location.POST_NAME,
 583        exp.LanguageProperty: exp.Properties.Location.POST_SCHEMA,
 584        exp.LikeProperty: exp.Properties.Location.POST_SCHEMA,
 585        exp.LocationProperty: exp.Properties.Location.POST_SCHEMA,
 586        exp.LockProperty: exp.Properties.Location.POST_SCHEMA,
 587        exp.LockingProperty: exp.Properties.Location.POST_ALIAS,
 588        exp.LogProperty: exp.Properties.Location.POST_NAME,
 589        exp.MaterializedProperty: exp.Properties.Location.POST_CREATE,
 590        exp.MergeBlockRatioProperty: exp.Properties.Location.POST_NAME,
 591        exp.NoPrimaryIndexProperty: exp.Properties.Location.POST_EXPRESSION,
 592        exp.OnProperty: exp.Properties.Location.POST_SCHEMA,
 593        exp.OnCommitProperty: exp.Properties.Location.POST_EXPRESSION,
 594        exp.Order: exp.Properties.Location.POST_SCHEMA,
 595        exp.OutputModelProperty: exp.Properties.Location.POST_SCHEMA,
 596        exp.PartitionedByProperty: exp.Properties.Location.POST_WITH,
 597        exp.PartitionedOfProperty: exp.Properties.Location.POST_SCHEMA,
 598        exp.PrimaryKey: exp.Properties.Location.POST_SCHEMA,
 599        exp.Property: exp.Properties.Location.POST_WITH,
 600        exp.RemoteWithConnectionModelProperty: exp.Properties.Location.POST_SCHEMA,
 601        exp.ReturnsProperty: exp.Properties.Location.POST_SCHEMA,
 602        exp.RowFormatProperty: exp.Properties.Location.POST_SCHEMA,
 603        exp.RowFormatDelimitedProperty: exp.Properties.Location.POST_SCHEMA,
 604        exp.RowFormatSerdeProperty: exp.Properties.Location.POST_SCHEMA,
 605        exp.SampleProperty: exp.Properties.Location.POST_SCHEMA,
 606        exp.SchemaCommentProperty: exp.Properties.Location.POST_SCHEMA,
 607        exp.SecureProperty: exp.Properties.Location.POST_CREATE,
 608        exp.SecurityProperty: exp.Properties.Location.POST_SCHEMA,
 609        exp.SerdeProperties: exp.Properties.Location.POST_SCHEMA,
 610        exp.Set: exp.Properties.Location.POST_SCHEMA,
 611        exp.SettingsProperty: exp.Properties.Location.POST_SCHEMA,
 612        exp.SetProperty: exp.Properties.Location.POST_CREATE,
 613        exp.SetConfigProperty: exp.Properties.Location.POST_SCHEMA,
 614        exp.SharingProperty: exp.Properties.Location.POST_EXPRESSION,
 615        exp.SequenceProperties: exp.Properties.Location.POST_EXPRESSION,
 616        exp.SortKeyProperty: exp.Properties.Location.POST_SCHEMA,
 617        exp.SqlReadWriteProperty: exp.Properties.Location.POST_SCHEMA,
 618        exp.SqlSecurityProperty: exp.Properties.Location.POST_CREATE,
 619        exp.StabilityProperty: exp.Properties.Location.POST_SCHEMA,
 620        exp.StorageHandlerProperty: exp.Properties.Location.POST_SCHEMA,
 621        exp.StreamingTableProperty: exp.Properties.Location.POST_CREATE,
 622        exp.StrictProperty: exp.Properties.Location.POST_SCHEMA,
 623        exp.Tags: exp.Properties.Location.POST_WITH,
 624        exp.TemporaryProperty: exp.Properties.Location.POST_CREATE,
 625        exp.ToTableProperty: exp.Properties.Location.POST_SCHEMA,
 626        exp.TransientProperty: exp.Properties.Location.POST_CREATE,
 627        exp.TransformModelProperty: exp.Properties.Location.POST_SCHEMA,
 628        exp.MergeTreeTTL: exp.Properties.Location.POST_SCHEMA,
 629        exp.UnloggedProperty: exp.Properties.Location.POST_CREATE,
 630        exp.UsingTemplateProperty: exp.Properties.Location.POST_SCHEMA,
 631        exp.ViewAttributeProperty: exp.Properties.Location.POST_SCHEMA,
 632        exp.VolatileProperty: exp.Properties.Location.POST_CREATE,
 633        exp.WithDataProperty: exp.Properties.Location.POST_EXPRESSION,
 634        exp.WithJournalTableProperty: exp.Properties.Location.POST_NAME,
 635        exp.WithProcedureOptions: exp.Properties.Location.POST_SCHEMA,
 636        exp.WithSchemaBindingProperty: exp.Properties.Location.POST_SCHEMA,
 637        exp.WithSystemVersioningProperty: exp.Properties.Location.POST_SCHEMA,
 638        exp.ForceProperty: exp.Properties.Location.POST_CREATE,
 639    }
 640
 641    # Keywords that can't be used as unquoted identifier names
 642    RESERVED_KEYWORDS: t.Set[str] = set()
 643
 644    # Expressions whose comments are separated from them for better formatting
 645    WITH_SEPARATED_COMMENTS: t.Tuple[t.Type[exp.Expression], ...] = (
 646        exp.Command,
 647        exp.Create,
 648        exp.Describe,
 649        exp.Delete,
 650        exp.Drop,
 651        exp.From,
 652        exp.Insert,
 653        exp.Join,
 654        exp.MultitableInserts,
 655        exp.Order,
 656        exp.Group,
 657        exp.Having,
 658        exp.Select,
 659        exp.SetOperation,
 660        exp.Update,
 661        exp.Where,
 662        exp.With,
 663    )
 664
 665    # Expressions that should not have their comments generated in maybe_comment
 666    EXCLUDE_COMMENTS: t.Tuple[t.Type[exp.Expression], ...] = (
 667        exp.Binary,
 668        exp.SetOperation,
 669    )
 670
 671    # Expressions that can remain unwrapped when appearing in the context of an INTERVAL
 672    UNWRAPPED_INTERVAL_VALUES: t.Tuple[t.Type[exp.Expression], ...] = (
 673        exp.Column,
 674        exp.Literal,
 675        exp.Neg,
 676        exp.Paren,
 677    )
 678
 679    PARAMETERIZABLE_TEXT_TYPES = {
 680        exp.DataType.Type.NVARCHAR,
 681        exp.DataType.Type.VARCHAR,
 682        exp.DataType.Type.CHAR,
 683        exp.DataType.Type.NCHAR,
 684    }
 685
 686    # Expressions that need to have all CTEs under them bubbled up to them
 687    EXPRESSIONS_WITHOUT_NESTED_CTES: t.Set[t.Type[exp.Expression]] = set()
 688
 689    RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS: t.Tuple[t.Type[exp.Expression], ...] = ()
 690
 691    SENTINEL_LINE_BREAK = "__SQLGLOT__LB__"
 692
 693    __slots__ = (
 694        "pretty",
 695        "identify",
 696        "normalize",
 697        "pad",
 698        "_indent",
 699        "normalize_functions",
 700        "unsupported_level",
 701        "max_unsupported",
 702        "leading_comma",
 703        "max_text_width",
 704        "comments",
 705        "dialect",
 706        "unsupported_messages",
 707        "_escaped_quote_end",
 708        "_escaped_identifier_end",
 709        "_next_name",
 710        "_identifier_start",
 711        "_identifier_end",
 712        "_quote_json_path_key_using_brackets",
 713    )
 714
 715    def __init__(
 716        self,
 717        pretty: t.Optional[bool] = None,
 718        identify: str | bool = False,
 719        normalize: bool = False,
 720        pad: int = 2,
 721        indent: int = 2,
 722        normalize_functions: t.Optional[str | bool] = None,
 723        unsupported_level: ErrorLevel = ErrorLevel.WARN,
 724        max_unsupported: int = 3,
 725        leading_comma: bool = False,
 726        max_text_width: int = 80,
 727        comments: bool = True,
 728        dialect: DialectType = None,
 729    ):
 730        import sqlglot
 731        from sqlglot.dialects import Dialect
 732
 733        self.pretty = pretty if pretty is not None else sqlglot.pretty
 734        self.identify = identify
 735        self.normalize = normalize
 736        self.pad = pad
 737        self._indent = indent
 738        self.unsupported_level = unsupported_level
 739        self.max_unsupported = max_unsupported
 740        self.leading_comma = leading_comma
 741        self.max_text_width = max_text_width
 742        self.comments = comments
 743        self.dialect = Dialect.get_or_raise(dialect)
 744
 745        # This is both a Dialect property and a Generator argument, so we prioritize the latter
 746        self.normalize_functions = (
 747            self.dialect.NORMALIZE_FUNCTIONS if normalize_functions is None else normalize_functions
 748        )
 749
 750        self.unsupported_messages: t.List[str] = []
 751        self._escaped_quote_end: str = (
 752            self.dialect.tokenizer_class.STRING_ESCAPES[0] + self.dialect.QUOTE_END
 753        )
 754        self._escaped_identifier_end = self.dialect.IDENTIFIER_END * 2
 755
 756        self._next_name = name_sequence("_t")
 757
 758        self._identifier_start = self.dialect.IDENTIFIER_START
 759        self._identifier_end = self.dialect.IDENTIFIER_END
 760
 761        self._quote_json_path_key_using_brackets = True
 762
 763    def generate(self, expression: exp.Expression, copy: bool = True) -> str:
 764        """
 765        Generates the SQL string corresponding to the given syntax tree.
 766
 767        Args:
 768            expression: The syntax tree.
 769            copy: Whether to copy the expression. The generator performs mutations so
 770                it is safer to copy.
 771
 772        Returns:
 773            The SQL string corresponding to `expression`.
 774        """
 775        if copy:
 776            expression = expression.copy()
 777
 778        expression = self.preprocess(expression)
 779
 780        self.unsupported_messages = []
 781        sql = self.sql(expression).strip()
 782
 783        if self.pretty:
 784            sql = sql.replace(self.SENTINEL_LINE_BREAK, "\n")
 785
 786        if self.unsupported_level == ErrorLevel.IGNORE:
 787            return sql
 788
 789        if self.unsupported_level == ErrorLevel.WARN:
 790            for msg in self.unsupported_messages:
 791                logger.warning(msg)
 792        elif self.unsupported_level == ErrorLevel.RAISE and self.unsupported_messages:
 793            raise UnsupportedError(concat_messages(self.unsupported_messages, self.max_unsupported))
 794
 795        return sql
 796
 797    def preprocess(self, expression: exp.Expression) -> exp.Expression:
 798        """Apply generic preprocessing transformations to a given expression."""
 799        expression = self._move_ctes_to_top_level(expression)
 800
 801        if self.ENSURE_BOOLS:
 802            from sqlglot.transforms import ensure_bools
 803
 804            expression = ensure_bools(expression)
 805
 806        return expression
 807
 808    def _move_ctes_to_top_level(self, expression: E) -> E:
 809        if (
 810            not expression.parent
 811            and type(expression) in self.EXPRESSIONS_WITHOUT_NESTED_CTES
 812            and any(node.parent is not expression for node in expression.find_all(exp.With))
 813        ):
 814            from sqlglot.transforms import move_ctes_to_top_level
 815
 816            expression = move_ctes_to_top_level(expression)
 817        return expression
 818
 819    def unsupported(self, message: str) -> None:
 820        if self.unsupported_level == ErrorLevel.IMMEDIATE:
 821            raise UnsupportedError(message)
 822        self.unsupported_messages.append(message)
 823
 824    def sep(self, sep: str = " ") -> str:
 825        return f"{sep.strip()}\n" if self.pretty else sep
 826
 827    def seg(self, sql: str, sep: str = " ") -> str:
 828        return f"{self.sep(sep)}{sql}"
 829
 830    def sanitize_comment(self, comment: str) -> str:
 831        comment = " " + comment if comment[0].strip() else comment
 832        comment = comment + " " if comment[-1].strip() else comment
 833
 834        if not self.dialect.tokenizer_class.NESTED_COMMENTS:
 835            # Necessary workaround to avoid syntax errors due to nesting: /* ... */ ... */
 836            comment = comment.replace("*/", "* /")
 837
 838        return comment
 839
 840    def maybe_comment(
 841        self,
 842        sql: str,
 843        expression: t.Optional[exp.Expression] = None,
 844        comments: t.Optional[t.List[str]] = None,
 845        separated: bool = False,
 846    ) -> str:
 847        comments = (
 848            ((expression and expression.comments) if comments is None else comments)  # type: ignore
 849            if self.comments
 850            else None
 851        )
 852
 853        if not comments or isinstance(expression, self.EXCLUDE_COMMENTS):
 854            return sql
 855
 856        comments_sql = " ".join(
 857            f"/*{self.sanitize_comment(comment)}*/" for comment in comments if comment
 858        )
 859
 860        if not comments_sql:
 861            return sql
 862
 863        comments_sql = self._replace_line_breaks(comments_sql)
 864
 865        if separated or isinstance(expression, self.WITH_SEPARATED_COMMENTS):
 866            return (
 867                f"{self.sep()}{comments_sql}{sql}"
 868                if not sql or sql[0].isspace()
 869                else f"{comments_sql}{self.sep()}{sql}"
 870            )
 871
 872        return f"{sql} {comments_sql}"
 873
 874    def wrap(self, expression: exp.Expression | str) -> str:
 875        this_sql = (
 876            self.sql(expression)
 877            if isinstance(expression, exp.UNWRAPPED_QUERIES)
 878            else self.sql(expression, "this")
 879        )
 880        if not this_sql:
 881            return "()"
 882
 883        this_sql = self.indent(this_sql, level=1, pad=0)
 884        return f"({self.sep('')}{this_sql}{self.seg(')', sep='')}"
 885
 886    def no_identify(self, func: t.Callable[..., str], *args, **kwargs) -> str:
 887        original = self.identify
 888        self.identify = False
 889        result = func(*args, **kwargs)
 890        self.identify = original
 891        return result
 892
 893    def normalize_func(self, name: str) -> str:
 894        if self.normalize_functions == "upper" or self.normalize_functions is True:
 895            return name.upper()
 896        if self.normalize_functions == "lower":
 897            return name.lower()
 898        return name
 899
 900    def indent(
 901        self,
 902        sql: str,
 903        level: int = 0,
 904        pad: t.Optional[int] = None,
 905        skip_first: bool = False,
 906        skip_last: bool = False,
 907    ) -> str:
 908        if not self.pretty or not sql:
 909            return sql
 910
 911        pad = self.pad if pad is None else pad
 912        lines = sql.split("\n")
 913
 914        return "\n".join(
 915            (
 916                line
 917                if (skip_first and i == 0) or (skip_last and i == len(lines) - 1)
 918                else f"{' ' * (level * self._indent + pad)}{line}"
 919            )
 920            for i, line in enumerate(lines)
 921        )
 922
 923    def sql(
 924        self,
 925        expression: t.Optional[str | exp.Expression],
 926        key: t.Optional[str] = None,
 927        comment: bool = True,
 928    ) -> str:
 929        if not expression:
 930            return ""
 931
 932        if isinstance(expression, str):
 933            return expression
 934
 935        if key:
 936            value = expression.args.get(key)
 937            if value:
 938                return self.sql(value)
 939            return ""
 940
 941        transform = self.TRANSFORMS.get(expression.__class__)
 942
 943        if callable(transform):
 944            sql = transform(self, expression)
 945        elif isinstance(expression, exp.Expression):
 946            exp_handler_name = f"{expression.key}_sql"
 947
 948            if hasattr(self, exp_handler_name):
 949                sql = getattr(self, exp_handler_name)(expression)
 950            elif isinstance(expression, exp.Func):
 951                sql = self.function_fallback_sql(expression)
 952            elif isinstance(expression, exp.Property):
 953                sql = self.property_sql(expression)
 954            else:
 955                raise ValueError(f"Unsupported expression type {expression.__class__.__name__}")
 956        else:
 957            raise ValueError(f"Expected an Expression. Received {type(expression)}: {expression}")
 958
 959        return self.maybe_comment(sql, expression) if self.comments and comment else sql
 960
 961    def uncache_sql(self, expression: exp.Uncache) -> str:
 962        table = self.sql(expression, "this")
 963        exists_sql = " IF EXISTS" if expression.args.get("exists") else ""
 964        return f"UNCACHE TABLE{exists_sql} {table}"
 965
 966    def cache_sql(self, expression: exp.Cache) -> str:
 967        lazy = " LAZY" if expression.args.get("lazy") else ""
 968        table = self.sql(expression, "this")
 969        options = expression.args.get("options")
 970        options = f" OPTIONS({self.sql(options[0])} = {self.sql(options[1])})" if options else ""
 971        sql = self.sql(expression, "expression")
 972        sql = f" AS{self.sep()}{sql}" if sql else ""
 973        sql = f"CACHE{lazy} TABLE {table}{options}{sql}"
 974        return self.prepend_ctes(expression, sql)
 975
 976    def characterset_sql(self, expression: exp.CharacterSet) -> str:
 977        if isinstance(expression.parent, exp.Cast):
 978            return f"CHAR CHARACTER SET {self.sql(expression, 'this')}"
 979        default = "DEFAULT " if expression.args.get("default") else ""
 980        return f"{default}CHARACTER SET={self.sql(expression, 'this')}"
 981
 982    def column_parts(self, expression: exp.Column) -> str:
 983        return ".".join(
 984            self.sql(part)
 985            for part in (
 986                expression.args.get("catalog"),
 987                expression.args.get("db"),
 988                expression.args.get("table"),
 989                expression.args.get("this"),
 990            )
 991            if part
 992        )
 993
 994    def column_sql(self, expression: exp.Column) -> str:
 995        join_mark = " (+)" if expression.args.get("join_mark") else ""
 996
 997        if join_mark and not self.dialect.SUPPORTS_COLUMN_JOIN_MARKS:
 998            join_mark = ""
 999            self.unsupported("Outer join syntax using the (+) operator is not supported.")
1000
1001        return f"{self.column_parts(expression)}{join_mark}"
1002
1003    def columnposition_sql(self, expression: exp.ColumnPosition) -> str:
1004        this = self.sql(expression, "this")
1005        this = f" {this}" if this else ""
1006        position = self.sql(expression, "position")
1007        return f"{position}{this}"
1008
1009    def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
1010        column = self.sql(expression, "this")
1011        kind = self.sql(expression, "kind")
1012        constraints = self.expressions(expression, key="constraints", sep=" ", flat=True)
1013        exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
1014        kind = f"{sep}{kind}" if kind else ""
1015        constraints = f" {constraints}" if constraints else ""
1016        position = self.sql(expression, "position")
1017        position = f" {position}" if position else ""
1018
1019        if expression.find(exp.ComputedColumnConstraint) and not self.COMPUTED_COLUMN_WITH_TYPE:
1020            kind = ""
1021
1022        return f"{exists}{column}{kind}{constraints}{position}"
1023
1024    def columnconstraint_sql(self, expression: exp.ColumnConstraint) -> str:
1025        this = self.sql(expression, "this")
1026        kind_sql = self.sql(expression, "kind").strip()
1027        return f"CONSTRAINT {this} {kind_sql}" if this else kind_sql
1028
1029    def computedcolumnconstraint_sql(self, expression: exp.ComputedColumnConstraint) -> str:
1030        this = self.sql(expression, "this")
1031        if expression.args.get("not_null"):
1032            persisted = " PERSISTED NOT NULL"
1033        elif expression.args.get("persisted"):
1034            persisted = " PERSISTED"
1035        else:
1036            persisted = ""
1037
1038        return f"AS {this}{persisted}"
1039
1040    def autoincrementcolumnconstraint_sql(self, _) -> str:
1041        return self.token_sql(TokenType.AUTO_INCREMENT)
1042
1043    def compresscolumnconstraint_sql(self, expression: exp.CompressColumnConstraint) -> str:
1044        if isinstance(expression.this, list):
1045            this = self.wrap(self.expressions(expression, key="this", flat=True))
1046        else:
1047            this = self.sql(expression, "this")
1048
1049        return f"COMPRESS {this}"
1050
1051    def generatedasidentitycolumnconstraint_sql(
1052        self, expression: exp.GeneratedAsIdentityColumnConstraint
1053    ) -> str:
1054        this = ""
1055        if expression.this is not None:
1056            on_null = " ON NULL" if expression.args.get("on_null") else ""
1057            this = " ALWAYS" if expression.this else f" BY DEFAULT{on_null}"
1058
1059        start = expression.args.get("start")
1060        start = f"START WITH {start}" if start else ""
1061        increment = expression.args.get("increment")
1062        increment = f" INCREMENT BY {increment}" if increment else ""
1063        minvalue = expression.args.get("minvalue")
1064        minvalue = f" MINVALUE {minvalue}" if minvalue else ""
1065        maxvalue = expression.args.get("maxvalue")
1066        maxvalue = f" MAXVALUE {maxvalue}" if maxvalue else ""
1067        cycle = expression.args.get("cycle")
1068        cycle_sql = ""
1069
1070        if cycle is not None:
1071            cycle_sql = f"{' NO' if not cycle else ''} CYCLE"
1072            cycle_sql = cycle_sql.strip() if not start and not increment else cycle_sql
1073
1074        sequence_opts = ""
1075        if start or increment or cycle_sql:
1076            sequence_opts = f"{start}{increment}{minvalue}{maxvalue}{cycle_sql}"
1077            sequence_opts = f" ({sequence_opts.strip()})"
1078
1079        expr = self.sql(expression, "expression")
1080        expr = f"({expr})" if expr else "IDENTITY"
1081
1082        return f"GENERATED{this} AS {expr}{sequence_opts}"
1083
1084    def generatedasrowcolumnconstraint_sql(
1085        self, expression: exp.GeneratedAsRowColumnConstraint
1086    ) -> str:
1087        start = "START" if expression.args.get("start") else "END"
1088        hidden = " HIDDEN" if expression.args.get("hidden") else ""
1089        return f"GENERATED ALWAYS AS ROW {start}{hidden}"
1090
1091    def periodforsystemtimeconstraint_sql(
1092        self, expression: exp.PeriodForSystemTimeConstraint
1093    ) -> str:
1094        return f"PERIOD FOR SYSTEM_TIME ({self.sql(expression, 'this')}, {self.sql(expression, 'expression')})"
1095
1096    def notnullcolumnconstraint_sql(self, expression: exp.NotNullColumnConstraint) -> str:
1097        return f"{'' if expression.args.get('allow_null') else 'NOT '}NULL"
1098
1099    def primarykeycolumnconstraint_sql(self, expression: exp.PrimaryKeyColumnConstraint) -> str:
1100        desc = expression.args.get("desc")
1101        if desc is not None:
1102            return f"PRIMARY KEY{' DESC' if desc else ' ASC'}"
1103        options = self.expressions(expression, key="options", flat=True, sep=" ")
1104        options = f" {options}" if options else ""
1105        return f"PRIMARY KEY{options}"
1106
1107    def uniquecolumnconstraint_sql(self, expression: exp.UniqueColumnConstraint) -> str:
1108        this = self.sql(expression, "this")
1109        this = f" {this}" if this else ""
1110        index_type = expression.args.get("index_type")
1111        index_type = f" USING {index_type}" if index_type else ""
1112        on_conflict = self.sql(expression, "on_conflict")
1113        on_conflict = f" {on_conflict}" if on_conflict else ""
1114        nulls_sql = " NULLS NOT DISTINCT" if expression.args.get("nulls") else ""
1115        options = self.expressions(expression, key="options", flat=True, sep=" ")
1116        options = f" {options}" if options else ""
1117        return f"UNIQUE{nulls_sql}{this}{index_type}{on_conflict}{options}"
1118
1119    def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str:
1120        return self.sql(expression, "this")
1121
1122    def create_sql(self, expression: exp.Create) -> str:
1123        kind = self.sql(expression, "kind")
1124        kind = self.dialect.INVERSE_CREATABLE_KIND_MAPPING.get(kind) or kind
1125        properties = expression.args.get("properties")
1126        properties_locs = self.locate_properties(properties) if properties else defaultdict()
1127
1128        this = self.createable_sql(expression, properties_locs)
1129
1130        properties_sql = ""
1131        if properties_locs.get(exp.Properties.Location.POST_SCHEMA) or properties_locs.get(
1132            exp.Properties.Location.POST_WITH
1133        ):
1134            properties_sql = self.sql(
1135                exp.Properties(
1136                    expressions=[
1137                        *properties_locs[exp.Properties.Location.POST_SCHEMA],
1138                        *properties_locs[exp.Properties.Location.POST_WITH],
1139                    ]
1140                )
1141            )
1142
1143            if properties_locs.get(exp.Properties.Location.POST_SCHEMA):
1144                properties_sql = self.sep() + properties_sql
1145            elif not self.pretty:
1146                # Standalone POST_WITH properties need a leading whitespace in non-pretty mode
1147                properties_sql = f" {properties_sql}"
1148
1149        begin = " BEGIN" if expression.args.get("begin") else ""
1150        end = " END" if expression.args.get("end") else ""
1151
1152        expression_sql = self.sql(expression, "expression")
1153        if expression_sql:
1154            expression_sql = f"{begin}{self.sep()}{expression_sql}{end}"
1155
1156            if self.CREATE_FUNCTION_RETURN_AS or not isinstance(expression.expression, exp.Return):
1157                postalias_props_sql = ""
1158                if properties_locs.get(exp.Properties.Location.POST_ALIAS):
1159                    postalias_props_sql = self.properties(
1160                        exp.Properties(
1161                            expressions=properties_locs[exp.Properties.Location.POST_ALIAS]
1162                        ),
1163                        wrapped=False,
1164                    )
1165                postalias_props_sql = f" {postalias_props_sql}" if postalias_props_sql else ""
1166                expression_sql = f" AS{postalias_props_sql}{expression_sql}"
1167
1168        postindex_props_sql = ""
1169        if properties_locs.get(exp.Properties.Location.POST_INDEX):
1170            postindex_props_sql = self.properties(
1171                exp.Properties(expressions=properties_locs[exp.Properties.Location.POST_INDEX]),
1172                wrapped=False,
1173                prefix=" ",
1174            )
1175
1176        indexes = self.expressions(expression, key="indexes", indent=False, sep=" ")
1177        indexes = f" {indexes}" if indexes else ""
1178        index_sql = indexes + postindex_props_sql
1179
1180        replace = " OR REPLACE" if expression.args.get("replace") else ""
1181        refresh = " OR REFRESH" if expression.args.get("refresh") else ""
1182        unique = " UNIQUE" if expression.args.get("unique") else ""
1183
1184        clustered = expression.args.get("clustered")
1185        if clustered is None:
1186            clustered_sql = ""
1187        elif clustered:
1188            clustered_sql = " CLUSTERED COLUMNSTORE"
1189        else:
1190            clustered_sql = " NONCLUSTERED COLUMNSTORE"
1191
1192        postcreate_props_sql = ""
1193        if properties_locs.get(exp.Properties.Location.POST_CREATE):
1194            postcreate_props_sql = self.properties(
1195                exp.Properties(expressions=properties_locs[exp.Properties.Location.POST_CREATE]),
1196                sep=" ",
1197                prefix=" ",
1198                wrapped=False,
1199            )
1200
1201        modifiers = "".join((clustered_sql, replace, refresh, unique, postcreate_props_sql))
1202
1203        postexpression_props_sql = ""
1204        if properties_locs.get(exp.Properties.Location.POST_EXPRESSION):
1205            postexpression_props_sql = self.properties(
1206                exp.Properties(
1207                    expressions=properties_locs[exp.Properties.Location.POST_EXPRESSION]
1208                ),
1209                sep=" ",
1210                prefix=" ",
1211                wrapped=False,
1212            )
1213
1214        concurrently = " CONCURRENTLY" if expression.args.get("concurrently") else ""
1215        exists_sql = " IF NOT EXISTS" if expression.args.get("exists") else ""
1216        no_schema_binding = (
1217            " WITH NO SCHEMA BINDING" if expression.args.get("no_schema_binding") else ""
1218        )
1219
1220        clone = self.sql(expression, "clone")
1221        clone = f" {clone}" if clone else ""
1222
1223        if kind in self.EXPRESSION_PRECEDES_PROPERTIES_CREATABLES:
1224            properties_expression = f"{expression_sql}{properties_sql}"
1225        else:
1226            properties_expression = f"{properties_sql}{expression_sql}"
1227
1228        expression_sql = f"CREATE{modifiers} {kind}{concurrently}{exists_sql} {this}{properties_expression}{postexpression_props_sql}{index_sql}{no_schema_binding}{clone}"
1229        return self.prepend_ctes(expression, expression_sql)
1230
1231    def sequenceproperties_sql(self, expression: exp.SequenceProperties) -> str:
1232        start = self.sql(expression, "start")
1233        start = f"START WITH {start}" if start else ""
1234        increment = self.sql(expression, "increment")
1235        increment = f" INCREMENT BY {increment}" if increment else ""
1236        minvalue = self.sql(expression, "minvalue")
1237        minvalue = f" MINVALUE {minvalue}" if minvalue else ""
1238        maxvalue = self.sql(expression, "maxvalue")
1239        maxvalue = f" MAXVALUE {maxvalue}" if maxvalue else ""
1240        owned = self.sql(expression, "owned")
1241        owned = f" OWNED BY {owned}" if owned else ""
1242
1243        cache = expression.args.get("cache")
1244        if cache is None:
1245            cache_str = ""
1246        elif cache is True:
1247            cache_str = " CACHE"
1248        else:
1249            cache_str = f" CACHE {cache}"
1250
1251        options = self.expressions(expression, key="options", flat=True, sep=" ")
1252        options = f" {options}" if options else ""
1253
1254        return f"{start}{increment}{minvalue}{maxvalue}{cache_str}{options}{owned}".lstrip()
1255
1256    def clone_sql(self, expression: exp.Clone) -> str:
1257        this = self.sql(expression, "this")
1258        shallow = "SHALLOW " if expression.args.get("shallow") else ""
1259        keyword = "COPY" if expression.args.get("copy") and self.SUPPORTS_TABLE_COPY else "CLONE"
1260        return f"{shallow}{keyword} {this}"
1261
1262    def describe_sql(self, expression: exp.Describe) -> str:
1263        style = expression.args.get("style")
1264        style = f" {style}" if style else ""
1265        partition = self.sql(expression, "partition")
1266        partition = f" {partition}" if partition else ""
1267        format = self.sql(expression, "format")
1268        format = f" {format}" if format else ""
1269
1270        return f"DESCRIBE{style}{format} {self.sql(expression, 'this')}{partition}"
1271
1272    def heredoc_sql(self, expression: exp.Heredoc) -> str:
1273        tag = self.sql(expression, "tag")
1274        return f"${tag}${self.sql(expression, 'this')}${tag}$"
1275
1276    def prepend_ctes(self, expression: exp.Expression, sql: str) -> str:
1277        with_ = self.sql(expression, "with")
1278        if with_:
1279            sql = f"{with_}{self.sep()}{sql}"
1280        return sql
1281
1282    def with_sql(self, expression: exp.With) -> str:
1283        sql = self.expressions(expression, flat=True)
1284        recursive = (
1285            "RECURSIVE "
1286            if self.CTE_RECURSIVE_KEYWORD_REQUIRED and expression.args.get("recursive")
1287            else ""
1288        )
1289        search = self.sql(expression, "search")
1290        search = f" {search}" if search else ""
1291
1292        return f"WITH {recursive}{sql}{search}"
1293
1294    def cte_sql(self, expression: exp.CTE) -> str:
1295        alias = expression.args.get("alias")
1296        if alias:
1297            alias.add_comments(expression.pop_comments())
1298
1299        alias_sql = self.sql(expression, "alias")
1300
1301        materialized = expression.args.get("materialized")
1302        if materialized is False:
1303            materialized = "NOT MATERIALIZED "
1304        elif materialized:
1305            materialized = "MATERIALIZED "
1306
1307        return f"{alias_sql} AS {materialized or ''}{self.wrap(expression)}"
1308
1309    def tablealias_sql(self, expression: exp.TableAlias) -> str:
1310        alias = self.sql(expression, "this")
1311        columns = self.expressions(expression, key="columns", flat=True)
1312        columns = f"({columns})" if columns else ""
1313
1314        if columns and not self.SUPPORTS_TABLE_ALIAS_COLUMNS:
1315            columns = ""
1316            self.unsupported("Named columns are not supported in table alias.")
1317
1318        if not alias and not self.dialect.UNNEST_COLUMN_ONLY:
1319            alias = self._next_name()
1320
1321        return f"{alias}{columns}"
1322
1323    def bitstring_sql(self, expression: exp.BitString) -> str:
1324        this = self.sql(expression, "this")
1325        if self.dialect.BIT_START:
1326            return f"{self.dialect.BIT_START}{this}{self.dialect.BIT_END}"
1327        return f"{int(this, 2)}"
1328
1329    def hexstring_sql(
1330        self, expression: exp.HexString, binary_function_repr: t.Optional[str] = None
1331    ) -> str:
1332        this = self.sql(expression, "this")
1333        is_integer_type = expression.args.get("is_integer")
1334
1335        if (is_integer_type and not self.dialect.HEX_STRING_IS_INTEGER_TYPE) or (
1336            not self.dialect.HEX_START and not binary_function_repr
1337        ):
1338            # Integer representation will be returned if:
1339            # - The read dialect treats the hex value as integer literal but not the write
1340            # - The transpilation is not supported (write dialect hasn't set HEX_START or the param flag)
1341            return f"{int(this, 16)}"
1342
1343        if not is_integer_type:
1344            # Read dialect treats the hex value as BINARY/BLOB
1345            if binary_function_repr:
1346                # The write dialect supports the transpilation to its equivalent BINARY/BLOB
1347                return self.func(binary_function_repr, exp.Literal.string(this))
1348            if self.dialect.HEX_STRING_IS_INTEGER_TYPE:
1349                # The write dialect does not support the transpilation, it'll treat the hex value as INTEGER
1350                self.unsupported("Unsupported transpilation from BINARY/BLOB hex string")
1351
1352        return f"{self.dialect.HEX_START}{this}{self.dialect.HEX_END}"
1353
1354    def bytestring_sql(self, expression: exp.ByteString) -> str:
1355        this = self.sql(expression, "this")
1356        if self.dialect.BYTE_START:
1357            return f"{self.dialect.BYTE_START}{this}{self.dialect.BYTE_END}"
1358        return this
1359
1360    def unicodestring_sql(self, expression: exp.UnicodeString) -> str:
1361        this = self.sql(expression, "this")
1362        escape = expression.args.get("escape")
1363
1364        if self.dialect.UNICODE_START:
1365            escape_substitute = r"\\\1"
1366            left_quote, right_quote = self.dialect.UNICODE_START, self.dialect.UNICODE_END
1367        else:
1368            escape_substitute = r"\\u\1"
1369            left_quote, right_quote = self.dialect.QUOTE_START, self.dialect.QUOTE_END
1370
1371        if escape:
1372            escape_pattern = re.compile(rf"{escape.name}(\d+)")
1373            escape_sql = f" UESCAPE {self.sql(escape)}" if self.SUPPORTS_UESCAPE else ""
1374        else:
1375            escape_pattern = ESCAPED_UNICODE_RE
1376            escape_sql = ""
1377
1378        if not self.dialect.UNICODE_START or (escape and not self.SUPPORTS_UESCAPE):
1379            this = escape_pattern.sub(escape_substitute, this)
1380
1381        return f"{left_quote}{this}{right_quote}{escape_sql}"
1382
1383    def rawstring_sql(self, expression: exp.RawString) -> str:
1384        string = expression.this
1385        if "\\" in self.dialect.tokenizer_class.STRING_ESCAPES:
1386            string = string.replace("\\", "\\\\")
1387
1388        string = self.escape_str(string, escape_backslash=False)
1389        return f"{self.dialect.QUOTE_START}{string}{self.dialect.QUOTE_END}"
1390
1391    def datatypeparam_sql(self, expression: exp.DataTypeParam) -> str:
1392        this = self.sql(expression, "this")
1393        specifier = self.sql(expression, "expression")
1394        specifier = f" {specifier}" if specifier and self.DATA_TYPE_SPECIFIERS_ALLOWED else ""
1395        return f"{this}{specifier}"
1396
1397    def datatype_sql(self, expression: exp.DataType) -> str:
1398        nested = ""
1399        values = ""
1400        interior = self.expressions(expression, flat=True)
1401
1402        type_value = expression.this
1403        if type_value == exp.DataType.Type.USERDEFINED and expression.args.get("kind"):
1404            type_sql = self.sql(expression, "kind")
1405        else:
1406            type_sql = (
1407                self.TYPE_MAPPING.get(type_value, type_value.value)
1408                if isinstance(type_value, exp.DataType.Type)
1409                else type_value
1410            )
1411
1412        if interior:
1413            if expression.args.get("nested"):
1414                nested = f"{self.STRUCT_DELIMITER[0]}{interior}{self.STRUCT_DELIMITER[1]}"
1415                if expression.args.get("values") is not None:
1416                    delimiters = ("[", "]") if type_value == exp.DataType.Type.ARRAY else ("(", ")")
1417                    values = self.expressions(expression, key="values", flat=True)
1418                    values = f"{delimiters[0]}{values}{delimiters[1]}"
1419            elif type_value == exp.DataType.Type.INTERVAL:
1420                nested = f" {interior}"
1421            else:
1422                nested = f"({interior})"
1423
1424        type_sql = f"{type_sql}{nested}{values}"
1425        if self.TZ_TO_WITH_TIME_ZONE and type_value in (
1426            exp.DataType.Type.TIMETZ,
1427            exp.DataType.Type.TIMESTAMPTZ,
1428        ):
1429            type_sql = f"{type_sql} WITH TIME ZONE"
1430
1431        return type_sql
1432
1433    def directory_sql(self, expression: exp.Directory) -> str:
1434        local = "LOCAL " if expression.args.get("local") else ""
1435        row_format = self.sql(expression, "row_format")
1436        row_format = f" {row_format}" if row_format else ""
1437        return f"{local}DIRECTORY {self.sql(expression, 'this')}{row_format}"
1438
1439    def delete_sql(self, expression: exp.Delete) -> str:
1440        this = self.sql(expression, "this")
1441        this = f" FROM {this}" if this else ""
1442        using = self.sql(expression, "using")
1443        using = f" USING {using}" if using else ""
1444        cluster = self.sql(expression, "cluster")
1445        cluster = f" {cluster}" if cluster else ""
1446        where = self.sql(expression, "where")
1447        returning = self.sql(expression, "returning")
1448        limit = self.sql(expression, "limit")
1449        tables = self.expressions(expression, key="tables")
1450        tables = f" {tables}" if tables else ""
1451        if self.RETURNING_END:
1452            expression_sql = f"{this}{using}{cluster}{where}{returning}{limit}"
1453        else:
1454            expression_sql = f"{returning}{this}{using}{cluster}{where}{limit}"
1455        return self.prepend_ctes(expression, f"DELETE{tables}{expression_sql}")
1456
1457    def drop_sql(self, expression: exp.Drop) -> str:
1458        this = self.sql(expression, "this")
1459        expressions = self.expressions(expression, flat=True)
1460        expressions = f" ({expressions})" if expressions else ""
1461        kind = expression.args["kind"]
1462        kind = self.dialect.INVERSE_CREATABLE_KIND_MAPPING.get(kind) or kind
1463        exists_sql = " IF EXISTS " if expression.args.get("exists") else " "
1464        concurrently_sql = " CONCURRENTLY" if expression.args.get("concurrently") else ""
1465        on_cluster = self.sql(expression, "cluster")
1466        on_cluster = f" {on_cluster}" if on_cluster else ""
1467        temporary = " TEMPORARY" if expression.args.get("temporary") else ""
1468        materialized = " MATERIALIZED" if expression.args.get("materialized") else ""
1469        cascade = " CASCADE" if expression.args.get("cascade") else ""
1470        constraints = " CONSTRAINTS" if expression.args.get("constraints") else ""
1471        purge = " PURGE" if expression.args.get("purge") else ""
1472        return f"DROP{temporary}{materialized} {kind}{concurrently_sql}{exists_sql}{this}{on_cluster}{expressions}{cascade}{constraints}{purge}"
1473
1474    def set_operation(self, expression: exp.SetOperation) -> str:
1475        op_type = type(expression)
1476        op_name = op_type.key.upper()
1477
1478        distinct = expression.args.get("distinct")
1479        if (
1480            distinct is False
1481            and op_type in (exp.Except, exp.Intersect)
1482            and not self.EXCEPT_INTERSECT_SUPPORT_ALL_CLAUSE
1483        ):
1484            self.unsupported(f"{op_name} ALL is not supported")
1485
1486        default_distinct = self.dialect.SET_OP_DISTINCT_BY_DEFAULT[op_type]
1487
1488        if distinct is None:
1489            distinct = default_distinct
1490            if distinct is None:
1491                self.unsupported(f"{op_name} requires DISTINCT or ALL to be specified")
1492
1493        if distinct is default_distinct:
1494            distinct_or_all = ""
1495        else:
1496            distinct_or_all = " DISTINCT" if distinct else " ALL"
1497
1498        side_kind = " ".join(filter(None, [expression.side, expression.kind]))
1499        side_kind = f"{side_kind} " if side_kind else ""
1500
1501        by_name = " BY NAME" if expression.args.get("by_name") else ""
1502        on = self.expressions(expression, key="on", flat=True)
1503        on = f" ON ({on})" if on else ""
1504
1505        return f"{side_kind}{op_name}{distinct_or_all}{by_name}{on}"
1506
1507    def set_operations(self, expression: exp.SetOperation) -> str:
1508        if not self.SET_OP_MODIFIERS:
1509            limit = expression.args.get("limit")
1510            order = expression.args.get("order")
1511
1512            if limit or order:
1513                select = self._move_ctes_to_top_level(
1514                    exp.subquery(expression, "_l_0", copy=False).select("*", copy=False)
1515                )
1516
1517                if limit:
1518                    select = select.limit(limit.pop(), copy=False)
1519                if order:
1520                    select = select.order_by(order.pop(), copy=False)
1521                return self.sql(select)
1522
1523        sqls: t.List[str] = []
1524        stack: t.List[t.Union[str, exp.Expression]] = [expression]
1525
1526        while stack:
1527            node = stack.pop()
1528
1529            if isinstance(node, exp.SetOperation):
1530                stack.append(node.expression)
1531                stack.append(
1532                    self.maybe_comment(
1533                        self.set_operation(node), comments=node.comments, separated=True
1534                    )
1535                )
1536                stack.append(node.this)
1537            else:
1538                sqls.append(self.sql(node))
1539
1540        this = self.sep().join(sqls)
1541        this = self.query_modifiers(expression, this)
1542        return self.prepend_ctes(expression, this)
1543
1544    def fetch_sql(self, expression: exp.Fetch) -> str:
1545        direction = expression.args.get("direction")
1546        direction = f" {direction}" if direction else ""
1547        count = self.sql(expression, "count")
1548        count = f" {count}" if count else ""
1549        limit_options = self.sql(expression, "limit_options")
1550        limit_options = f"{limit_options}" if limit_options else " ROWS ONLY"
1551        return f"{self.seg('FETCH')}{direction}{count}{limit_options}"
1552
1553    def limitoptions_sql(self, expression: exp.LimitOptions) -> str:
1554        percent = " PERCENT" if expression.args.get("percent") else ""
1555        rows = " ROWS" if expression.args.get("rows") else ""
1556        with_ties = " WITH TIES" if expression.args.get("with_ties") else ""
1557        if not with_ties and rows:
1558            with_ties = " ONLY"
1559        return f"{percent}{rows}{with_ties}"
1560
1561    def filter_sql(self, expression: exp.Filter) -> str:
1562        if self.AGGREGATE_FILTER_SUPPORTED:
1563            this = self.sql(expression, "this")
1564            where = self.sql(expression, "expression").strip()
1565            return f"{this} FILTER({where})"
1566
1567        agg = expression.this
1568        agg_arg = agg.this
1569        cond = expression.expression.this
1570        agg_arg.replace(exp.If(this=cond.copy(), true=agg_arg.copy()))
1571        return self.sql(agg)
1572
1573    def hint_sql(self, expression: exp.Hint) -> str:
1574        if not self.QUERY_HINTS:
1575            self.unsupported("Hints are not supported")
1576            return ""
1577
1578        return f" /*+ {self.expressions(expression, sep=self.QUERY_HINT_SEP).strip()} */"
1579
1580    def indexparameters_sql(self, expression: exp.IndexParameters) -> str:
1581        using = self.sql(expression, "using")
1582        using = f" USING {using}" if using else ""
1583        columns = self.expressions(expression, key="columns", flat=True)
1584        columns = f"({columns})" if columns else ""
1585        partition_by = self.expressions(expression, key="partition_by", flat=True)
1586        partition_by = f" PARTITION BY {partition_by}" if partition_by else ""
1587        where = self.sql(expression, "where")
1588        include = self.expressions(expression, key="include", flat=True)
1589        if include:
1590            include = f" INCLUDE ({include})"
1591        with_storage = self.expressions(expression, key="with_storage", flat=True)
1592        with_storage = f" WITH ({with_storage})" if with_storage else ""
1593        tablespace = self.sql(expression, "tablespace")
1594        tablespace = f" USING INDEX TABLESPACE {tablespace}" if tablespace else ""
1595        on = self.sql(expression, "on")
1596        on = f" ON {on}" if on else ""
1597
1598        return f"{using}{columns}{include}{with_storage}{tablespace}{partition_by}{where}{on}"
1599
1600    def index_sql(self, expression: exp.Index) -> str:
1601        unique = "UNIQUE " if expression.args.get("unique") else ""
1602        primary = "PRIMARY " if expression.args.get("primary") else ""
1603        amp = "AMP " if expression.args.get("amp") else ""
1604        name = self.sql(expression, "this")
1605        name = f"{name} " if name else ""
1606        table = self.sql(expression, "table")
1607        table = f"{self.INDEX_ON} {table}" if table else ""
1608
1609        index = "INDEX " if not table else ""
1610
1611        params = self.sql(expression, "params")
1612        return f"{unique}{primary}{amp}{index}{name}{table}{params}"
1613
1614    def identifier_sql(self, expression: exp.Identifier) -> str:
1615        text = expression.name
1616        lower = text.lower()
1617        text = lower if self.normalize and not expression.quoted else text
1618        text = text.replace(self._identifier_end, self._escaped_identifier_end)
1619        if (
1620            expression.quoted
1621            or self.dialect.can_identify(text, self.identify)
1622            or lower in self.RESERVED_KEYWORDS
1623            or (not self.dialect.IDENTIFIERS_CAN_START_WITH_DIGIT and text[:1].isdigit())
1624        ):
1625            text = f"{self._identifier_start}{text}{self._identifier_end}"
1626        return text
1627
1628    def hex_sql(self, expression: exp.Hex) -> str:
1629        text = self.func(self.HEX_FUNC, self.sql(expression, "this"))
1630        if self.dialect.HEX_LOWERCASE:
1631            text = self.func("LOWER", text)
1632
1633        return text
1634
1635    def lowerhex_sql(self, expression: exp.LowerHex) -> str:
1636        text = self.func(self.HEX_FUNC, self.sql(expression, "this"))
1637        if not self.dialect.HEX_LOWERCASE:
1638            text = self.func("LOWER", text)
1639        return text
1640
1641    def inputoutputformat_sql(self, expression: exp.InputOutputFormat) -> str:
1642        input_format = self.sql(expression, "input_format")
1643        input_format = f"INPUTFORMAT {input_format}" if input_format else ""
1644        output_format = self.sql(expression, "output_format")
1645        output_format = f"OUTPUTFORMAT {output_format}" if output_format else ""
1646        return self.sep().join((input_format, output_format))
1647
1648    def national_sql(self, expression: exp.National, prefix: str = "N") -> str:
1649        string = self.sql(exp.Literal.string(expression.name))
1650        return f"{prefix}{string}"
1651
1652    def partition_sql(self, expression: exp.Partition) -> str:
1653        partition_keyword = "SUBPARTITION" if expression.args.get("subpartition") else "PARTITION"
1654        return f"{partition_keyword}({self.expressions(expression, flat=True)})"
1655
1656    def properties_sql(self, expression: exp.Properties) -> str:
1657        root_properties = []
1658        with_properties = []
1659
1660        for p in expression.expressions:
1661            p_loc = self.PROPERTIES_LOCATION[p.__class__]
1662            if p_loc == exp.Properties.Location.POST_WITH:
1663                with_properties.append(p)
1664            elif p_loc == exp.Properties.Location.POST_SCHEMA:
1665                root_properties.append(p)
1666
1667        root_props = self.root_properties(exp.Properties(expressions=root_properties))
1668        with_props = self.with_properties(exp.Properties(expressions=with_properties))
1669
1670        if root_props and with_props and not self.pretty:
1671            with_props = " " + with_props
1672
1673        return root_props + with_props
1674
1675    def root_properties(self, properties: exp.Properties) -> str:
1676        if properties.expressions:
1677            return self.expressions(properties, indent=False, sep=" ")
1678        return ""
1679
1680    def properties(
1681        self,
1682        properties: exp.Properties,
1683        prefix: str = "",
1684        sep: str = ", ",
1685        suffix: str = "",
1686        wrapped: bool = True,
1687    ) -> str:
1688        if properties.expressions:
1689            expressions = self.expressions(properties, sep=sep, indent=False)
1690            if expressions:
1691                expressions = self.wrap(expressions) if wrapped else expressions
1692                return f"{prefix}{' ' if prefix.strip() else ''}{expressions}{suffix}"
1693        return ""
1694
1695    def with_properties(self, properties: exp.Properties) -> str:
1696        return self.properties(properties, prefix=self.seg(self.WITH_PROPERTIES_PREFIX, sep=""))
1697
1698    def locate_properties(self, properties: exp.Properties) -> t.DefaultDict:
1699        properties_locs = defaultdict(list)
1700        for p in properties.expressions:
1701            p_loc = self.PROPERTIES_LOCATION[p.__class__]
1702            if p_loc != exp.Properties.Location.UNSUPPORTED:
1703                properties_locs[p_loc].append(p)
1704            else:
1705                self.unsupported(f"Unsupported property {p.key}")
1706
1707        return properties_locs
1708
1709    def property_name(self, expression: exp.Property, string_key: bool = False) -> str:
1710        if isinstance(expression.this, exp.Dot):
1711            return self.sql(expression, "this")
1712        return f"'{expression.name}'" if string_key else expression.name
1713
1714    def property_sql(self, expression: exp.Property) -> str:
1715        property_cls = expression.__class__
1716        if property_cls == exp.Property:
1717            return f"{self.property_name(expression)}={self.sql(expression, 'value')}"
1718
1719        property_name = exp.Properties.PROPERTY_TO_NAME.get(property_cls)
1720        if not property_name:
1721            self.unsupported(f"Unsupported property {expression.key}")
1722
1723        return f"{property_name}={self.sql(expression, 'this')}"
1724
1725    def likeproperty_sql(self, expression: exp.LikeProperty) -> str:
1726        if self.SUPPORTS_CREATE_TABLE_LIKE:
1727            options = " ".join(f"{e.name} {self.sql(e, 'value')}" for e in expression.expressions)
1728            options = f" {options}" if options else ""
1729
1730            like = f"LIKE {self.sql(expression, 'this')}{options}"
1731            if self.LIKE_PROPERTY_INSIDE_SCHEMA and not isinstance(expression.parent, exp.Schema):
1732                like = f"({like})"
1733
1734            return like
1735
1736        if expression.expressions:
1737            self.unsupported("Transpilation of LIKE property options is unsupported")
1738
1739        select = exp.select("*").from_(expression.this).limit(0)
1740        return f"AS {self.sql(select)}"
1741
1742    def fallbackproperty_sql(self, expression: exp.FallbackProperty) -> str:
1743        no = "NO " if expression.args.get("no") else ""
1744        protection = " PROTECTION" if expression.args.get("protection") else ""
1745        return f"{no}FALLBACK{protection}"
1746
1747    def journalproperty_sql(self, expression: exp.JournalProperty) -> str:
1748        no = "NO " if expression.args.get("no") else ""
1749        local = expression.args.get("local")
1750        local = f"{local} " if local else ""
1751        dual = "DUAL " if expression.args.get("dual") else ""
1752        before = "BEFORE " if expression.args.get("before") else ""
1753        after = "AFTER " if expression.args.get("after") else ""
1754        return f"{no}{local}{dual}{before}{after}JOURNAL"
1755
1756    def freespaceproperty_sql(self, expression: exp.FreespaceProperty) -> str:
1757        freespace = self.sql(expression, "this")
1758        percent = " PERCENT" if expression.args.get("percent") else ""
1759        return f"FREESPACE={freespace}{percent}"
1760
1761    def checksumproperty_sql(self, expression: exp.ChecksumProperty) -> str:
1762        if expression.args.get("default"):
1763            property = "DEFAULT"
1764        elif expression.args.get("on"):
1765            property = "ON"
1766        else:
1767            property = "OFF"
1768        return f"CHECKSUM={property}"
1769
1770    def mergeblockratioproperty_sql(self, expression: exp.MergeBlockRatioProperty) -> str:
1771        if expression.args.get("no"):
1772            return "NO MERGEBLOCKRATIO"
1773        if expression.args.get("default"):
1774            return "DEFAULT MERGEBLOCKRATIO"
1775
1776        percent = " PERCENT" if expression.args.get("percent") else ""
1777        return f"MERGEBLOCKRATIO={self.sql(expression, 'this')}{percent}"
1778
1779    def datablocksizeproperty_sql(self, expression: exp.DataBlocksizeProperty) -> str:
1780        default = expression.args.get("default")
1781        minimum = expression.args.get("minimum")
1782        maximum = expression.args.get("maximum")
1783        if default or minimum or maximum:
1784            if default:
1785                prop = "DEFAULT"
1786            elif minimum:
1787                prop = "MINIMUM"
1788            else:
1789                prop = "MAXIMUM"
1790            return f"{prop} DATABLOCKSIZE"
1791        units = expression.args.get("units")
1792        units = f" {units}" if units else ""
1793        return f"DATABLOCKSIZE={self.sql(expression, 'size')}{units}"
1794
1795    def blockcompressionproperty_sql(self, expression: exp.BlockCompressionProperty) -> str:
1796        autotemp = expression.args.get("autotemp")
1797        always = expression.args.get("always")
1798        default = expression.args.get("default")
1799        manual = expression.args.get("manual")
1800        never = expression.args.get("never")
1801
1802        if autotemp is not None:
1803            prop = f"AUTOTEMP({self.expressions(autotemp)})"
1804        elif always:
1805            prop = "ALWAYS"
1806        elif default:
1807            prop = "DEFAULT"
1808        elif manual:
1809            prop = "MANUAL"
1810        elif never:
1811            prop = "NEVER"
1812        return f"BLOCKCOMPRESSION={prop}"
1813
1814    def isolatedloadingproperty_sql(self, expression: exp.IsolatedLoadingProperty) -> str:
1815        no = expression.args.get("no")
1816        no = " NO" if no else ""
1817        concurrent = expression.args.get("concurrent")
1818        concurrent = " CONCURRENT" if concurrent else ""
1819        target = self.sql(expression, "target")
1820        target = f" {target}" if target else ""
1821        return f"WITH{no}{concurrent} ISOLATED LOADING{target}"
1822
1823    def partitionboundspec_sql(self, expression: exp.PartitionBoundSpec) -> str:
1824        if isinstance(expression.this, list):
1825            return f"IN ({self.expressions(expression, key='this', flat=True)})"
1826        if expression.this:
1827            modulus = self.sql(expression, "this")
1828            remainder = self.sql(expression, "expression")
1829            return f"WITH (MODULUS {modulus}, REMAINDER {remainder})"
1830
1831        from_expressions = self.expressions(expression, key="from_expressions", flat=True)
1832        to_expressions = self.expressions(expression, key="to_expressions", flat=True)
1833        return f"FROM ({from_expressions}) TO ({to_expressions})"
1834
1835    def partitionedofproperty_sql(self, expression: exp.PartitionedOfProperty) -> str:
1836        this = self.sql(expression, "this")
1837
1838        for_values_or_default = expression.expression
1839        if isinstance(for_values_or_default, exp.PartitionBoundSpec):
1840            for_values_or_default = f" FOR VALUES {self.sql(for_values_or_default)}"
1841        else:
1842            for_values_or_default = " DEFAULT"
1843
1844        return f"PARTITION OF {this}{for_values_or_default}"
1845
1846    def lockingproperty_sql(self, expression: exp.LockingProperty) -> str:
1847        kind = expression.args.get("kind")
1848        this = f" {self.sql(expression, 'this')}" if expression.this else ""
1849        for_or_in = expression.args.get("for_or_in")
1850        for_or_in = f" {for_or_in}" if for_or_in else ""
1851        lock_type = expression.args.get("lock_type")
1852        override = " OVERRIDE" if expression.args.get("override") else ""
1853        return f"LOCKING {kind}{this}{for_or_in} {lock_type}{override}"
1854
1855    def withdataproperty_sql(self, expression: exp.WithDataProperty) -> str:
1856        data_sql = f"WITH {'NO ' if expression.args.get('no') else ''}DATA"
1857        statistics = expression.args.get("statistics")
1858        statistics_sql = ""
1859        if statistics is not None:
1860            statistics_sql = f" AND {'NO ' if not statistics else ''}STATISTICS"
1861        return f"{data_sql}{statistics_sql}"
1862
1863    def withsystemversioningproperty_sql(self, expression: exp.WithSystemVersioningProperty) -> str:
1864        this = self.sql(expression, "this")
1865        this = f"HISTORY_TABLE={this}" if this else ""
1866        data_consistency: t.Optional[str] = self.sql(expression, "data_consistency")
1867        data_consistency = (
1868            f"DATA_CONSISTENCY_CHECK={data_consistency}" if data_consistency else None
1869        )
1870        retention_period: t.Optional[str] = self.sql(expression, "retention_period")
1871        retention_period = (
1872            f"HISTORY_RETENTION_PERIOD={retention_period}" if retention_period else None
1873        )
1874
1875        if this:
1876            on_sql = self.func("ON", this, data_consistency, retention_period)
1877        else:
1878            on_sql = "ON" if expression.args.get("on") else "OFF"
1879
1880        sql = f"SYSTEM_VERSIONING={on_sql}"
1881
1882        return f"WITH({sql})" if expression.args.get("with") else sql
1883
1884    def insert_sql(self, expression: exp.Insert) -> str:
1885        hint = self.sql(expression, "hint")
1886        overwrite = expression.args.get("overwrite")
1887
1888        if isinstance(expression.this, exp.Directory):
1889            this = " OVERWRITE" if overwrite else " INTO"
1890        else:
1891            this = self.INSERT_OVERWRITE if overwrite else " INTO"
1892
1893        stored = self.sql(expression, "stored")
1894        stored = f" {stored}" if stored else ""
1895        alternative = expression.args.get("alternative")
1896        alternative = f" OR {alternative}" if alternative else ""
1897        ignore = " IGNORE" if expression.args.get("ignore") else ""
1898        is_function = expression.args.get("is_function")
1899        if is_function:
1900            this = f"{this} FUNCTION"
1901        this = f"{this} {self.sql(expression, 'this')}"
1902
1903        exists = " IF EXISTS" if expression.args.get("exists") else ""
1904        where = self.sql(expression, "where")
1905        where = f"{self.sep()}REPLACE WHERE {where}" if where else ""
1906        expression_sql = f"{self.sep()}{self.sql(expression, 'expression')}"
1907        on_conflict = self.sql(expression, "conflict")
1908        on_conflict = f" {on_conflict}" if on_conflict else ""
1909        by_name = " BY NAME" if expression.args.get("by_name") else ""
1910        returning = self.sql(expression, "returning")
1911
1912        if self.RETURNING_END:
1913            expression_sql = f"{expression_sql}{on_conflict}{returning}"
1914        else:
1915            expression_sql = f"{returning}{expression_sql}{on_conflict}"
1916
1917        partition_by = self.sql(expression, "partition")
1918        partition_by = f" {partition_by}" if partition_by else ""
1919        settings = self.sql(expression, "settings")
1920        settings = f" {settings}" if settings else ""
1921
1922        source = self.sql(expression, "source")
1923        source = f"TABLE {source}" if source else ""
1924
1925        sql = f"INSERT{hint}{alternative}{ignore}{this}{stored}{by_name}{exists}{partition_by}{settings}{where}{expression_sql}{source}"
1926        return self.prepend_ctes(expression, sql)
1927
1928    def introducer_sql(self, expression: exp.Introducer) -> str:
1929        return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}"
1930
1931    def kill_sql(self, expression: exp.Kill) -> str:
1932        kind = self.sql(expression, "kind")
1933        kind = f" {kind}" if kind else ""
1934        this = self.sql(expression, "this")
1935        this = f" {this}" if this else ""
1936        return f"KILL{kind}{this}"
1937
1938    def pseudotype_sql(self, expression: exp.PseudoType) -> str:
1939        return expression.name
1940
1941    def objectidentifier_sql(self, expression: exp.ObjectIdentifier) -> str:
1942        return expression.name
1943
1944    def onconflict_sql(self, expression: exp.OnConflict) -> str:
1945        conflict = "ON DUPLICATE KEY" if expression.args.get("duplicate") else "ON CONFLICT"
1946
1947        constraint = self.sql(expression, "constraint")
1948        constraint = f" ON CONSTRAINT {constraint}" if constraint else ""
1949
1950        conflict_keys = self.expressions(expression, key="conflict_keys", flat=True)
1951        conflict_keys = f"({conflict_keys}) " if conflict_keys else " "
1952        action = self.sql(expression, "action")
1953
1954        expressions = self.expressions(expression, flat=True)
1955        if expressions:
1956            set_keyword = "SET " if self.DUPLICATE_KEY_UPDATE_WITH_SET else ""
1957            expressions = f" {set_keyword}{expressions}"
1958
1959        where = self.sql(expression, "where")
1960        return f"{conflict}{constraint}{conflict_keys}{action}{expressions}{where}"
1961
1962    def returning_sql(self, expression: exp.Returning) -> str:
1963        return f"{self.seg('RETURNING')} {self.expressions(expression, flat=True)}"
1964
1965    def rowformatdelimitedproperty_sql(self, expression: exp.RowFormatDelimitedProperty) -> str:
1966        fields = self.sql(expression, "fields")
1967        fields = f" FIELDS TERMINATED BY {fields}" if fields else ""
1968        escaped = self.sql(expression, "escaped")
1969        escaped = f" ESCAPED BY {escaped}" if escaped else ""
1970        items = self.sql(expression, "collection_items")
1971        items = f" COLLECTION ITEMS TERMINATED BY {items}" if items else ""
1972        keys = self.sql(expression, "map_keys")
1973        keys = f" MAP KEYS TERMINATED BY {keys}" if keys else ""
1974        lines = self.sql(expression, "lines")
1975        lines = f" LINES TERMINATED BY {lines}" if lines else ""
1976        null = self.sql(expression, "null")
1977        null = f" NULL DEFINED AS {null}" if null else ""
1978        return f"ROW FORMAT DELIMITED{fields}{escaped}{items}{keys}{lines}{null}"
1979
1980    def withtablehint_sql(self, expression: exp.WithTableHint) -> str:
1981        return f"WITH ({self.expressions(expression, flat=True)})"
1982
1983    def indextablehint_sql(self, expression: exp.IndexTableHint) -> str:
1984        this = f"{self.sql(expression, 'this')} INDEX"
1985        target = self.sql(expression, "target")
1986        target = f" FOR {target}" if target else ""
1987        return f"{this}{target} ({self.expressions(expression, flat=True)})"
1988
1989    def historicaldata_sql(self, expression: exp.HistoricalData) -> str:
1990        this = self.sql(expression, "this")
1991        kind = self.sql(expression, "kind")
1992        expr = self.sql(expression, "expression")
1993        return f"{this} ({kind} => {expr})"
1994
1995    def table_parts(self, expression: exp.Table) -> str:
1996        return ".".join(
1997            self.sql(part)
1998            for part in (
1999                expression.args.get("catalog"),
2000                expression.args.get("db"),
2001                expression.args.get("this"),
2002            )
2003            if part is not None
2004        )
2005
2006    def table_sql(self, expression: exp.Table, sep: str = " AS ") -> str:
2007        table = self.table_parts(expression)
2008        only = "ONLY " if expression.args.get("only") else ""
2009        partition = self.sql(expression, "partition")
2010        partition = f" {partition}" if partition else ""
2011        version = self.sql(expression, "version")
2012        version = f" {version}" if version else ""
2013        alias = self.sql(expression, "alias")
2014        alias = f"{sep}{alias}" if alias else ""
2015
2016        sample = self.sql(expression, "sample")
2017        if self.dialect.ALIAS_POST_TABLESAMPLE:
2018            sample_pre_alias = sample
2019            sample_post_alias = ""
2020        else:
2021            sample_pre_alias = ""
2022            sample_post_alias = sample
2023
2024        hints = self.expressions(expression, key="hints", sep=" ")
2025        hints = f" {hints}" if hints and self.TABLE_HINTS else ""
2026        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2027        joins = self.indent(
2028            self.expressions(expression, key="joins", sep="", flat=True), skip_first=True
2029        )
2030        laterals = self.expressions(expression, key="laterals", sep="")
2031
2032        file_format = self.sql(expression, "format")
2033        if file_format:
2034            pattern = self.sql(expression, "pattern")
2035            pattern = f", PATTERN => {pattern}" if pattern else ""
2036            file_format = f" (FILE_FORMAT => {file_format}{pattern})"
2037
2038        ordinality = expression.args.get("ordinality") or ""
2039        if ordinality:
2040            ordinality = f" WITH ORDINALITY{alias}"
2041            alias = ""
2042
2043        when = self.sql(expression, "when")
2044        if when:
2045            table = f"{table} {when}"
2046
2047        changes = self.sql(expression, "changes")
2048        changes = f" {changes}" if changes else ""
2049
2050        rows_from = self.expressions(expression, key="rows_from")
2051        if rows_from:
2052            table = f"ROWS FROM {self.wrap(rows_from)}"
2053
2054        return f"{only}{table}{changes}{partition}{version}{file_format}{sample_pre_alias}{alias}{hints}{pivots}{sample_post_alias}{joins}{laterals}{ordinality}"
2055
2056    def tablefromrows_sql(self, expression: exp.TableFromRows) -> str:
2057        table = self.func("TABLE", expression.this)
2058        alias = self.sql(expression, "alias")
2059        alias = f" AS {alias}" if alias else ""
2060        sample = self.sql(expression, "sample")
2061        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2062        joins = self.indent(
2063            self.expressions(expression, key="joins", sep="", flat=True), skip_first=True
2064        )
2065        return f"{table}{alias}{pivots}{sample}{joins}"
2066
2067    def tablesample_sql(
2068        self,
2069        expression: exp.TableSample,
2070        tablesample_keyword: t.Optional[str] = None,
2071    ) -> str:
2072        method = self.sql(expression, "method")
2073        method = f"{method} " if method and self.TABLESAMPLE_WITH_METHOD else ""
2074        numerator = self.sql(expression, "bucket_numerator")
2075        denominator = self.sql(expression, "bucket_denominator")
2076        field = self.sql(expression, "bucket_field")
2077        field = f" ON {field}" if field else ""
2078        bucket = f"BUCKET {numerator} OUT OF {denominator}{field}" if numerator else ""
2079        seed = self.sql(expression, "seed")
2080        seed = f" {self.TABLESAMPLE_SEED_KEYWORD} ({seed})" if seed else ""
2081
2082        size = self.sql(expression, "size")
2083        if size and self.TABLESAMPLE_SIZE_IS_ROWS:
2084            size = f"{size} ROWS"
2085
2086        percent = self.sql(expression, "percent")
2087        if percent and not self.dialect.TABLESAMPLE_SIZE_IS_PERCENT:
2088            percent = f"{percent} PERCENT"
2089
2090        expr = f"{bucket}{percent}{size}"
2091        if self.TABLESAMPLE_REQUIRES_PARENS:
2092            expr = f"({expr})"
2093
2094        return f" {tablesample_keyword or self.TABLESAMPLE_KEYWORDS} {method}{expr}{seed}"
2095
2096    def pivot_sql(self, expression: exp.Pivot) -> str:
2097        expressions = self.expressions(expression, flat=True)
2098        direction = "UNPIVOT" if expression.unpivot else "PIVOT"
2099
2100        group = self.sql(expression, "group")
2101
2102        if expression.this:
2103            this = self.sql(expression, "this")
2104            if not expressions:
2105                return f"UNPIVOT {this}"
2106
2107            on = f"{self.seg('ON')} {expressions}"
2108            into = self.sql(expression, "into")
2109            into = f"{self.seg('INTO')} {into}" if into else ""
2110            using = self.expressions(expression, key="using", flat=True)
2111            using = f"{self.seg('USING')} {using}" if using else ""
2112            return f"{direction} {this}{on}{into}{using}{group}"
2113
2114        alias = self.sql(expression, "alias")
2115        alias = f" AS {alias}" if alias else ""
2116
2117        fields = self.expressions(
2118            expression,
2119            "fields",
2120            sep=" ",
2121            dynamic=True,
2122            new_line=True,
2123            skip_first=True,
2124            skip_last=True,
2125        )
2126
2127        include_nulls = expression.args.get("include_nulls")
2128        if include_nulls is not None:
2129            nulls = " INCLUDE NULLS " if include_nulls else " EXCLUDE NULLS "
2130        else:
2131            nulls = ""
2132
2133        default_on_null = self.sql(expression, "default_on_null")
2134        default_on_null = f" DEFAULT ON NULL ({default_on_null})" if default_on_null else ""
2135        return f"{self.seg(direction)}{nulls}({expressions} FOR {fields}{default_on_null}{group}){alias}"
2136
2137    def version_sql(self, expression: exp.Version) -> str:
2138        this = f"FOR {expression.name}"
2139        kind = expression.text("kind")
2140        expr = self.sql(expression, "expression")
2141        return f"{this} {kind} {expr}"
2142
2143    def tuple_sql(self, expression: exp.Tuple) -> str:
2144        return f"({self.expressions(expression, dynamic=True, new_line=True, skip_first=True, skip_last=True)})"
2145
2146    def update_sql(self, expression: exp.Update) -> str:
2147        this = self.sql(expression, "this")
2148        set_sql = self.expressions(expression, flat=True)
2149        from_sql = self.sql(expression, "from")
2150        where_sql = self.sql(expression, "where")
2151        returning = self.sql(expression, "returning")
2152        order = self.sql(expression, "order")
2153        limit = self.sql(expression, "limit")
2154        if self.RETURNING_END:
2155            expression_sql = f"{from_sql}{where_sql}{returning}"
2156        else:
2157            expression_sql = f"{returning}{from_sql}{where_sql}"
2158        sql = f"UPDATE {this} SET {set_sql}{expression_sql}{order}{limit}"
2159        return self.prepend_ctes(expression, sql)
2160
2161    def values_sql(self, expression: exp.Values, values_as_table: bool = True) -> str:
2162        values_as_table = values_as_table and self.VALUES_AS_TABLE
2163
2164        # The VALUES clause is still valid in an `INSERT INTO ..` statement, for example
2165        if values_as_table or not expression.find_ancestor(exp.From, exp.Join):
2166            args = self.expressions(expression)
2167            alias = self.sql(expression, "alias")
2168            values = f"VALUES{self.seg('')}{args}"
2169            values = (
2170                f"({values})"
2171                if self.WRAP_DERIVED_VALUES
2172                and (alias or isinstance(expression.parent, (exp.From, exp.Table)))
2173                else values
2174            )
2175            return f"{values} AS {alias}" if alias else values
2176
2177        # Converts `VALUES...` expression into a series of select unions.
2178        alias_node = expression.args.get("alias")
2179        column_names = alias_node and alias_node.columns
2180
2181        selects: t.List[exp.Query] = []
2182
2183        for i, tup in enumerate(expression.expressions):
2184            row = tup.expressions
2185
2186            if i == 0 and column_names:
2187                row = [
2188                    exp.alias_(value, column_name) for value, column_name in zip(row, column_names)
2189                ]
2190
2191            selects.append(exp.Select(expressions=row))
2192
2193        if self.pretty:
2194            # This may result in poor performance for large-cardinality `VALUES` tables, due to
2195            # the deep nesting of the resulting exp.Unions. If this is a problem, either increase
2196            # `sys.setrecursionlimit` to avoid RecursionErrors, or don't set `pretty`.
2197            query = reduce(lambda x, y: exp.union(x, y, distinct=False, copy=False), selects)
2198            return self.subquery_sql(query.subquery(alias_node and alias_node.this, copy=False))
2199
2200        alias = f" AS {self.sql(alias_node, 'this')}" if alias_node else ""
2201        unions = " UNION ALL ".join(self.sql(select) for select in selects)
2202        return f"({unions}){alias}"
2203
2204    def var_sql(self, expression: exp.Var) -> str:
2205        return self.sql(expression, "this")
2206
2207    @unsupported_args("expressions")
2208    def into_sql(self, expression: exp.Into) -> str:
2209        temporary = " TEMPORARY" if expression.args.get("temporary") else ""
2210        unlogged = " UNLOGGED" if expression.args.get("unlogged") else ""
2211        return f"{self.seg('INTO')}{temporary or unlogged} {self.sql(expression, 'this')}"
2212
2213    def from_sql(self, expression: exp.From) -> str:
2214        return f"{self.seg('FROM')} {self.sql(expression, 'this')}"
2215
2216    def groupingsets_sql(self, expression: exp.GroupingSets) -> str:
2217        grouping_sets = self.expressions(expression, indent=False)
2218        return f"GROUPING SETS {self.wrap(grouping_sets)}"
2219
2220    def rollup_sql(self, expression: exp.Rollup) -> str:
2221        expressions = self.expressions(expression, indent=False)
2222        return f"ROLLUP {self.wrap(expressions)}" if expressions else "WITH ROLLUP"
2223
2224    def cube_sql(self, expression: exp.Cube) -> str:
2225        expressions = self.expressions(expression, indent=False)
2226        return f"CUBE {self.wrap(expressions)}" if expressions else "WITH CUBE"
2227
2228    def group_sql(self, expression: exp.Group) -> str:
2229        group_by_all = expression.args.get("all")
2230        if group_by_all is True:
2231            modifier = " ALL"
2232        elif group_by_all is False:
2233            modifier = " DISTINCT"
2234        else:
2235            modifier = ""
2236
2237        group_by = self.op_expressions(f"GROUP BY{modifier}", expression)
2238
2239        grouping_sets = self.expressions(expression, key="grouping_sets")
2240        cube = self.expressions(expression, key="cube")
2241        rollup = self.expressions(expression, key="rollup")
2242
2243        groupings = csv(
2244            self.seg(grouping_sets) if grouping_sets else "",
2245            self.seg(cube) if cube else "",
2246            self.seg(rollup) if rollup else "",
2247            self.seg("WITH TOTALS") if expression.args.get("totals") else "",
2248            sep=self.GROUPINGS_SEP,
2249        )
2250
2251        if (
2252            expression.expressions
2253            and groupings
2254            and groupings.strip() not in ("WITH CUBE", "WITH ROLLUP")
2255        ):
2256            group_by = f"{group_by}{self.GROUPINGS_SEP}"
2257
2258        return f"{group_by}{groupings}"
2259
2260    def having_sql(self, expression: exp.Having) -> str:
2261        this = self.indent(self.sql(expression, "this"))
2262        return f"{self.seg('HAVING')}{self.sep()}{this}"
2263
2264    def connect_sql(self, expression: exp.Connect) -> str:
2265        start = self.sql(expression, "start")
2266        start = self.seg(f"START WITH {start}") if start else ""
2267        nocycle = " NOCYCLE" if expression.args.get("nocycle") else ""
2268        connect = self.sql(expression, "connect")
2269        connect = self.seg(f"CONNECT BY{nocycle} {connect}")
2270        return start + connect
2271
2272    def prior_sql(self, expression: exp.Prior) -> str:
2273        return f"PRIOR {self.sql(expression, 'this')}"
2274
2275    def join_sql(self, expression: exp.Join) -> str:
2276        if not self.SEMI_ANTI_JOIN_WITH_SIDE and expression.kind in ("SEMI", "ANTI"):
2277            side = None
2278        else:
2279            side = expression.side
2280
2281        op_sql = " ".join(
2282            op
2283            for op in (
2284                expression.method,
2285                "GLOBAL" if expression.args.get("global") else None,
2286                side,
2287                expression.kind,
2288                expression.hint if self.JOIN_HINTS else None,
2289            )
2290            if op
2291        )
2292        match_cond = self.sql(expression, "match_condition")
2293        match_cond = f" MATCH_CONDITION ({match_cond})" if match_cond else ""
2294        on_sql = self.sql(expression, "on")
2295        using = expression.args.get("using")
2296
2297        if not on_sql and using:
2298            on_sql = csv(*(self.sql(column) for column in using))
2299
2300        this = expression.this
2301        this_sql = self.sql(this)
2302
2303        exprs = self.expressions(expression)
2304        if exprs:
2305            this_sql = f"{this_sql},{self.seg(exprs)}"
2306
2307        if on_sql:
2308            on_sql = self.indent(on_sql, skip_first=True)
2309            space = self.seg(" " * self.pad) if self.pretty else " "
2310            if using:
2311                on_sql = f"{space}USING ({on_sql})"
2312            else:
2313                on_sql = f"{space}ON {on_sql}"
2314        elif not op_sql:
2315            if isinstance(this, exp.Lateral) and this.args.get("cross_apply") is not None:
2316                return f" {this_sql}"
2317
2318            return f", {this_sql}"
2319
2320        if op_sql != "STRAIGHT_JOIN":
2321            op_sql = f"{op_sql} JOIN" if op_sql else "JOIN"
2322
2323        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2324        return f"{self.seg(op_sql)} {this_sql}{match_cond}{on_sql}{pivots}"
2325
2326    def lambda_sql(self, expression: exp.Lambda, arrow_sep: str = "->", wrap: bool = True) -> str:
2327        args = self.expressions(expression, flat=True)
2328        args = f"({args})" if wrap and len(args.split(",")) > 1 else args
2329        return f"{args} {arrow_sep} {self.sql(expression, 'this')}"
2330
2331    def lateral_op(self, expression: exp.Lateral) -> str:
2332        cross_apply = expression.args.get("cross_apply")
2333
2334        # https://www.mssqltips.com/sqlservertip/1958/sql-server-cross-apply-and-outer-apply/
2335        if cross_apply is True:
2336            op = "INNER JOIN "
2337        elif cross_apply is False:
2338            op = "LEFT JOIN "
2339        else:
2340            op = ""
2341
2342        return f"{op}LATERAL"
2343
2344    def lateral_sql(self, expression: exp.Lateral) -> str:
2345        this = self.sql(expression, "this")
2346
2347        if expression.args.get("view"):
2348            alias = expression.args["alias"]
2349            columns = self.expressions(alias, key="columns", flat=True)
2350            table = f" {alias.name}" if alias.name else ""
2351            columns = f" AS {columns}" if columns else ""
2352            op_sql = self.seg(f"LATERAL VIEW{' OUTER' if expression.args.get('outer') else ''}")
2353            return f"{op_sql}{self.sep()}{this}{table}{columns}"
2354
2355        alias = self.sql(expression, "alias")
2356        alias = f" AS {alias}" if alias else ""
2357
2358        ordinality = expression.args.get("ordinality") or ""
2359        if ordinality:
2360            ordinality = f" WITH ORDINALITY{alias}"
2361            alias = ""
2362
2363        return f"{self.lateral_op(expression)} {this}{alias}{ordinality}"
2364
2365    def limit_sql(self, expression: exp.Limit, top: bool = False) -> str:
2366        this = self.sql(expression, "this")
2367
2368        args = [
2369            self._simplify_unless_literal(e) if self.LIMIT_ONLY_LITERALS else e
2370            for e in (expression.args.get(k) for k in ("offset", "expression"))
2371            if e
2372        ]
2373
2374        args_sql = ", ".join(self.sql(e) for e in args)
2375        args_sql = f"({args_sql})" if top and any(not e.is_number for e in args) else args_sql
2376        expressions = self.expressions(expression, flat=True)
2377        limit_options = self.sql(expression, "limit_options")
2378        expressions = f" BY {expressions}" if expressions else ""
2379
2380        return f"{this}{self.seg('TOP' if top else 'LIMIT')} {args_sql}{limit_options}{expressions}"
2381
2382    def offset_sql(self, expression: exp.Offset) -> str:
2383        this = self.sql(expression, "this")
2384        value = expression.expression
2385        value = self._simplify_unless_literal(value) if self.LIMIT_ONLY_LITERALS else value
2386        expressions = self.expressions(expression, flat=True)
2387        expressions = f" BY {expressions}" if expressions else ""
2388        return f"{this}{self.seg('OFFSET')} {self.sql(value)}{expressions}"
2389
2390    def setitem_sql(self, expression: exp.SetItem) -> str:
2391        kind = self.sql(expression, "kind")
2392        kind = f"{kind} " if kind else ""
2393        this = self.sql(expression, "this")
2394        expressions = self.expressions(expression)
2395        collate = self.sql(expression, "collate")
2396        collate = f" COLLATE {collate}" if collate else ""
2397        global_ = "GLOBAL " if expression.args.get("global") else ""
2398        return f"{global_}{kind}{this}{expressions}{collate}"
2399
2400    def set_sql(self, expression: exp.Set) -> str:
2401        expressions = f" {self.expressions(expression, flat=True)}"
2402        tag = " TAG" if expression.args.get("tag") else ""
2403        return f"{'UNSET' if expression.args.get('unset') else 'SET'}{tag}{expressions}"
2404
2405    def pragma_sql(self, expression: exp.Pragma) -> str:
2406        return f"PRAGMA {self.sql(expression, 'this')}"
2407
2408    def lock_sql(self, expression: exp.Lock) -> str:
2409        if not self.LOCKING_READS_SUPPORTED:
2410            self.unsupported("Locking reads using 'FOR UPDATE/SHARE' are not supported")
2411            return ""
2412
2413        update = expression.args["update"]
2414        key = expression.args.get("key")
2415        if update:
2416            lock_type = "FOR NO KEY UPDATE" if key else "FOR UPDATE"
2417        else:
2418            lock_type = "FOR KEY SHARE" if key else "FOR SHARE"
2419        expressions = self.expressions(expression, flat=True)
2420        expressions = f" OF {expressions}" if expressions else ""
2421        wait = expression.args.get("wait")
2422
2423        if wait is not None:
2424            if isinstance(wait, exp.Literal):
2425                wait = f" WAIT {self.sql(wait)}"
2426            else:
2427                wait = " NOWAIT" if wait else " SKIP LOCKED"
2428
2429        return f"{lock_type}{expressions}{wait or ''}"
2430
2431    def literal_sql(self, expression: exp.Literal) -> str:
2432        text = expression.this or ""
2433        if expression.is_string:
2434            text = f"{self.dialect.QUOTE_START}{self.escape_str(text)}{self.dialect.QUOTE_END}"
2435        return text
2436
2437    def escape_str(self, text: str, escape_backslash: bool = True) -> str:
2438        if self.dialect.ESCAPED_SEQUENCES:
2439            to_escaped = self.dialect.ESCAPED_SEQUENCES
2440            text = "".join(
2441                to_escaped.get(ch, ch) if escape_backslash or ch != "\\" else ch for ch in text
2442            )
2443
2444        return self._replace_line_breaks(text).replace(
2445            self.dialect.QUOTE_END, self._escaped_quote_end
2446        )
2447
2448    def loaddata_sql(self, expression: exp.LoadData) -> str:
2449        local = " LOCAL" if expression.args.get("local") else ""
2450        inpath = f" INPATH {self.sql(expression, 'inpath')}"
2451        overwrite = " OVERWRITE" if expression.args.get("overwrite") else ""
2452        this = f" INTO TABLE {self.sql(expression, 'this')}"
2453        partition = self.sql(expression, "partition")
2454        partition = f" {partition}" if partition else ""
2455        input_format = self.sql(expression, "input_format")
2456        input_format = f" INPUTFORMAT {input_format}" if input_format else ""
2457        serde = self.sql(expression, "serde")
2458        serde = f" SERDE {serde}" if serde else ""
2459        return f"LOAD DATA{local}{inpath}{overwrite}{this}{partition}{input_format}{serde}"
2460
2461    def null_sql(self, *_) -> str:
2462        return "NULL"
2463
2464    def boolean_sql(self, expression: exp.Boolean) -> str:
2465        return "TRUE" if expression.this else "FALSE"
2466
2467    def order_sql(self, expression: exp.Order, flat: bool = False) -> str:
2468        this = self.sql(expression, "this")
2469        this = f"{this} " if this else this
2470        siblings = "SIBLINGS " if expression.args.get("siblings") else ""
2471        return self.op_expressions(f"{this}ORDER {siblings}BY", expression, flat=this or flat)  # type: ignore
2472
2473    def withfill_sql(self, expression: exp.WithFill) -> str:
2474        from_sql = self.sql(expression, "from")
2475        from_sql = f" FROM {from_sql}" if from_sql else ""
2476        to_sql = self.sql(expression, "to")
2477        to_sql = f" TO {to_sql}" if to_sql else ""
2478        step_sql = self.sql(expression, "step")
2479        step_sql = f" STEP {step_sql}" if step_sql else ""
2480        interpolated_values = [
2481            f"{self.sql(e, 'alias')} AS {self.sql(e, 'this')}"
2482            if isinstance(e, exp.Alias)
2483            else self.sql(e, "this")
2484            for e in expression.args.get("interpolate") or []
2485        ]
2486        interpolate = (
2487            f" INTERPOLATE ({', '.join(interpolated_values)})" if interpolated_values else ""
2488        )
2489        return f"WITH FILL{from_sql}{to_sql}{step_sql}{interpolate}"
2490
2491    def cluster_sql(self, expression: exp.Cluster) -> str:
2492        return self.op_expressions("CLUSTER BY", expression)
2493
2494    def distribute_sql(self, expression: exp.Distribute) -> str:
2495        return self.op_expressions("DISTRIBUTE BY", expression)
2496
2497    def sort_sql(self, expression: exp.Sort) -> str:
2498        return self.op_expressions("SORT BY", expression)
2499
2500    def ordered_sql(self, expression: exp.Ordered) -> str:
2501        desc = expression.args.get("desc")
2502        asc = not desc
2503
2504        nulls_first = expression.args.get("nulls_first")
2505        nulls_last = not nulls_first
2506        nulls_are_large = self.dialect.NULL_ORDERING == "nulls_are_large"
2507        nulls_are_small = self.dialect.NULL_ORDERING == "nulls_are_small"
2508        nulls_are_last = self.dialect.NULL_ORDERING == "nulls_are_last"
2509
2510        this = self.sql(expression, "this")
2511
2512        sort_order = " DESC" if desc else (" ASC" if desc is False else "")
2513        nulls_sort_change = ""
2514        if nulls_first and (
2515            (asc and nulls_are_large) or (desc and nulls_are_small) or nulls_are_last
2516        ):
2517            nulls_sort_change = " NULLS FIRST"
2518        elif (
2519            nulls_last
2520            and ((asc and nulls_are_small) or (desc and nulls_are_large))
2521            and not nulls_are_last
2522        ):
2523            nulls_sort_change = " NULLS LAST"
2524
2525        # If the NULLS FIRST/LAST clause is unsupported, we add another sort key to simulate it
2526        if nulls_sort_change and not self.NULL_ORDERING_SUPPORTED:
2527            window = expression.find_ancestor(exp.Window, exp.Select)
2528            if isinstance(window, exp.Window) and window.args.get("spec"):
2529                self.unsupported(
2530                    f"'{nulls_sort_change.strip()}' translation not supported in window functions"
2531                )
2532                nulls_sort_change = ""
2533            elif self.NULL_ORDERING_SUPPORTED is False and (
2534                (asc and nulls_sort_change == " NULLS LAST")
2535                or (desc and nulls_sort_change == " NULLS FIRST")
2536            ):
2537                # BigQuery does not allow these ordering/nulls combinations when used under
2538                # an aggregation func or under a window containing one
2539                ancestor = expression.find_ancestor(exp.AggFunc, exp.Window, exp.Select)
2540
2541                if isinstance(ancestor, exp.Window):
2542                    ancestor = ancestor.this
2543                if isinstance(ancestor, exp.AggFunc):
2544                    self.unsupported(
2545                        f"'{nulls_sort_change.strip()}' translation not supported for aggregate functions with {sort_order} sort order"
2546                    )
2547                    nulls_sort_change = ""
2548            elif self.NULL_ORDERING_SUPPORTED is None:
2549                if expression.this.is_int:
2550                    self.unsupported(
2551                        f"'{nulls_sort_change.strip()}' translation not supported with positional ordering"
2552                    )
2553                elif not isinstance(expression.this, exp.Rand):
2554                    null_sort_order = " DESC" if nulls_sort_change == " NULLS FIRST" else ""
2555                    this = f"CASE WHEN {this} IS NULL THEN 1 ELSE 0 END{null_sort_order}, {this}"
2556                nulls_sort_change = ""
2557
2558        with_fill = self.sql(expression, "with_fill")
2559        with_fill = f" {with_fill}" if with_fill else ""
2560
2561        return f"{this}{sort_order}{nulls_sort_change}{with_fill}"
2562
2563    def matchrecognizemeasure_sql(self, expression: exp.MatchRecognizeMeasure) -> str:
2564        window_frame = self.sql(expression, "window_frame")
2565        window_frame = f"{window_frame} " if window_frame else ""
2566
2567        this = self.sql(expression, "this")
2568
2569        return f"{window_frame}{this}"
2570
2571    def matchrecognize_sql(self, expression: exp.MatchRecognize) -> str:
2572        partition = self.partition_by_sql(expression)
2573        order = self.sql(expression, "order")
2574        measures = self.expressions(expression, key="measures")
2575        measures = self.seg(f"MEASURES{self.seg(measures)}") if measures else ""
2576        rows = self.sql(expression, "rows")
2577        rows = self.seg(rows) if rows else ""
2578        after = self.sql(expression, "after")
2579        after = self.seg(after) if after else ""
2580        pattern = self.sql(expression, "pattern")
2581        pattern = self.seg(f"PATTERN ({pattern})") if pattern else ""
2582        definition_sqls = [
2583            f"{self.sql(definition, 'alias')} AS {self.sql(definition, 'this')}"
2584            for definition in expression.args.get("define", [])
2585        ]
2586        definitions = self.expressions(sqls=definition_sqls)
2587        define = self.seg(f"DEFINE{self.seg(definitions)}") if definitions else ""
2588        body = "".join(
2589            (
2590                partition,
2591                order,
2592                measures,
2593                rows,
2594                after,
2595                pattern,
2596                define,
2597            )
2598        )
2599        alias = self.sql(expression, "alias")
2600        alias = f" {alias}" if alias else ""
2601        return f"{self.seg('MATCH_RECOGNIZE')} {self.wrap(body)}{alias}"
2602
2603    def query_modifiers(self, expression: exp.Expression, *sqls: str) -> str:
2604        limit = expression.args.get("limit")
2605
2606        if self.LIMIT_FETCH == "LIMIT" and isinstance(limit, exp.Fetch):
2607            limit = exp.Limit(expression=exp.maybe_copy(limit.args.get("count")))
2608        elif self.LIMIT_FETCH == "FETCH" and isinstance(limit, exp.Limit):
2609            limit = exp.Fetch(direction="FIRST", count=exp.maybe_copy(limit.expression))
2610
2611        return csv(
2612            *sqls,
2613            *[self.sql(join) for join in expression.args.get("joins") or []],
2614            self.sql(expression, "match"),
2615            *[self.sql(lateral) for lateral in expression.args.get("laterals") or []],
2616            self.sql(expression, "prewhere"),
2617            self.sql(expression, "where"),
2618            self.sql(expression, "connect"),
2619            self.sql(expression, "group"),
2620            self.sql(expression, "having"),
2621            *[gen(self, expression) for gen in self.AFTER_HAVING_MODIFIER_TRANSFORMS.values()],
2622            self.sql(expression, "order"),
2623            *self.offset_limit_modifiers(expression, isinstance(limit, exp.Fetch), limit),
2624            *self.after_limit_modifiers(expression),
2625            self.options_modifier(expression),
2626            self.for_modifiers(expression),
2627            sep="",
2628        )
2629
2630    def options_modifier(self, expression: exp.Expression) -> str:
2631        options = self.expressions(expression, key="options")
2632        return f" {options}" if options else ""
2633
2634    def for_modifiers(self, expression: exp.Expression) -> str:
2635        for_modifiers = self.expressions(expression, key="for")
2636        return f"{self.sep()}FOR XML{self.seg(for_modifiers)}" if for_modifiers else ""
2637
2638    def queryoption_sql(self, expression: exp.QueryOption) -> str:
2639        self.unsupported("Unsupported query option.")
2640        return ""
2641
2642    def offset_limit_modifiers(
2643        self, expression: exp.Expression, fetch: bool, limit: t.Optional[exp.Fetch | exp.Limit]
2644    ) -> t.List[str]:
2645        return [
2646            self.sql(expression, "offset") if fetch else self.sql(limit),
2647            self.sql(limit) if fetch else self.sql(expression, "offset"),
2648        ]
2649
2650    def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]:
2651        locks = self.expressions(expression, key="locks", sep=" ")
2652        locks = f" {locks}" if locks else ""
2653        return [locks, self.sql(expression, "sample")]
2654
2655    def select_sql(self, expression: exp.Select) -> str:
2656        into = expression.args.get("into")
2657        if not self.SUPPORTS_SELECT_INTO and into:
2658            into.pop()
2659
2660        hint = self.sql(expression, "hint")
2661        distinct = self.sql(expression, "distinct")
2662        distinct = f" {distinct}" if distinct else ""
2663        kind = self.sql(expression, "kind")
2664
2665        limit = expression.args.get("limit")
2666        if isinstance(limit, exp.Limit) and self.LIMIT_IS_TOP:
2667            top = self.limit_sql(limit, top=True)
2668            limit.pop()
2669        else:
2670            top = ""
2671
2672        expressions = self.expressions(expression)
2673
2674        if kind:
2675            if kind in self.SELECT_KINDS:
2676                kind = f" AS {kind}"
2677            else:
2678                if kind == "STRUCT":
2679                    expressions = self.expressions(
2680                        sqls=[
2681                            self.sql(
2682                                exp.Struct(
2683                                    expressions=[
2684                                        exp.PropertyEQ(this=e.args.get("alias"), expression=e.this)
2685                                        if isinstance(e, exp.Alias)
2686                                        else e
2687                                        for e in expression.expressions
2688                                    ]
2689                                )
2690                            )
2691                        ]
2692                    )
2693                kind = ""
2694
2695        operation_modifiers = self.expressions(expression, key="operation_modifiers", sep=" ")
2696        operation_modifiers = f"{self.sep()}{operation_modifiers}" if operation_modifiers else ""
2697
2698        # We use LIMIT_IS_TOP as a proxy for whether DISTINCT should go first because tsql and Teradata
2699        # are the only dialects that use LIMIT_IS_TOP and both place DISTINCT first.
2700        top_distinct = f"{distinct}{hint}{top}" if self.LIMIT_IS_TOP else f"{top}{hint}{distinct}"
2701        expressions = f"{self.sep()}{expressions}" if expressions else expressions
2702        sql = self.query_modifiers(
2703            expression,
2704            f"SELECT{top_distinct}{operation_modifiers}{kind}{expressions}",
2705            self.sql(expression, "into", comment=False),
2706            self.sql(expression, "from", comment=False),
2707        )
2708
2709        # If both the CTE and SELECT clauses have comments, generate the latter earlier
2710        if expression.args.get("with"):
2711            sql = self.maybe_comment(sql, expression)
2712            expression.pop_comments()
2713
2714        sql = self.prepend_ctes(expression, sql)
2715
2716        if not self.SUPPORTS_SELECT_INTO and into:
2717            if into.args.get("temporary"):
2718                table_kind = " TEMPORARY"
2719            elif self.SUPPORTS_UNLOGGED_TABLES and into.args.get("unlogged"):
2720                table_kind = " UNLOGGED"
2721            else:
2722                table_kind = ""
2723            sql = f"CREATE{table_kind} TABLE {self.sql(into.this)} AS {sql}"
2724
2725        return sql
2726
2727    def schema_sql(self, expression: exp.Schema) -> str:
2728        this = self.sql(expression, "this")
2729        sql = self.schema_columns_sql(expression)
2730        return f"{this} {sql}" if this and sql else this or sql
2731
2732    def schema_columns_sql(self, expression: exp.Schema) -> str:
2733        if expression.expressions:
2734            return f"({self.sep('')}{self.expressions(expression)}{self.seg(')', sep='')}"
2735        return ""
2736
2737    def star_sql(self, expression: exp.Star) -> str:
2738        except_ = self.expressions(expression, key="except", flat=True)
2739        except_ = f"{self.seg(self.STAR_EXCEPT)} ({except_})" if except_ else ""
2740        replace = self.expressions(expression, key="replace", flat=True)
2741        replace = f"{self.seg('REPLACE')} ({replace})" if replace else ""
2742        rename = self.expressions(expression, key="rename", flat=True)
2743        rename = f"{self.seg('RENAME')} ({rename})" if rename else ""
2744        return f"*{except_}{replace}{rename}"
2745
2746    def parameter_sql(self, expression: exp.Parameter) -> str:
2747        this = self.sql(expression, "this")
2748        return f"{self.PARAMETER_TOKEN}{this}"
2749
2750    def sessionparameter_sql(self, expression: exp.SessionParameter) -> str:
2751        this = self.sql(expression, "this")
2752        kind = expression.text("kind")
2753        if kind:
2754            kind = f"{kind}."
2755        return f"@@{kind}{this}"
2756
2757    def placeholder_sql(self, expression: exp.Placeholder) -> str:
2758        return f"{self.NAMED_PLACEHOLDER_TOKEN}{expression.name}" if expression.this else "?"
2759
2760    def subquery_sql(self, expression: exp.Subquery, sep: str = " AS ") -> str:
2761        alias = self.sql(expression, "alias")
2762        alias = f"{sep}{alias}" if alias else ""
2763        sample = self.sql(expression, "sample")
2764        if self.dialect.ALIAS_POST_TABLESAMPLE and sample:
2765            alias = f"{sample}{alias}"
2766
2767            # Set to None so it's not generated again by self.query_modifiers()
2768            expression.set("sample", None)
2769
2770        pivots = self.expressions(expression, key="pivots", sep="", flat=True)
2771        sql = self.query_modifiers(expression, self.wrap(expression), alias, pivots)
2772        return self.prepend_ctes(expression, sql)
2773
2774    def qualify_sql(self, expression: exp.Qualify) -> str:
2775        this = self.indent(self.sql(expression, "this"))
2776        return f"{self.seg('QUALIFY')}{self.sep()}{this}"
2777
2778    def unnest_sql(self, expression: exp.Unnest) -> str:
2779        args = self.expressions(expression, flat=True)
2780
2781        alias = expression.args.get("alias")
2782        offset = expression.args.get("offset")
2783
2784        if self.UNNEST_WITH_ORDINALITY:
2785            if alias and isinstance(offset, exp.Expression):
2786                alias.append("columns", offset)
2787
2788        if alias and self.dialect.UNNEST_COLUMN_ONLY:
2789            columns = alias.columns
2790            alias = self.sql(columns[0]) if columns else ""
2791        else:
2792            alias = self.sql(alias)
2793
2794        alias = f" AS {alias}" if alias else alias
2795        if self.UNNEST_WITH_ORDINALITY:
2796            suffix = f" WITH ORDINALITY{alias}" if offset else alias
2797        else:
2798            if isinstance(offset, exp.Expression):
2799                suffix = f"{alias} WITH OFFSET AS {self.sql(offset)}"
2800            elif offset:
2801                suffix = f"{alias} WITH OFFSET"
2802            else:
2803                suffix = alias
2804
2805        return f"UNNEST({args}){suffix}"
2806
2807    def prewhere_sql(self, expression: exp.PreWhere) -> str:
2808        return ""
2809
2810    def where_sql(self, expression: exp.Where) -> str:
2811        this = self.indent(self.sql(expression, "this"))
2812        return f"{self.seg('WHERE')}{self.sep()}{this}"
2813
2814    def window_sql(self, expression: exp.Window) -> str:
2815        this = self.sql(expression, "this")
2816        partition = self.partition_by_sql(expression)
2817        order = expression.args.get("order")
2818        order = self.order_sql(order, flat=True) if order else ""
2819        spec = self.sql(expression, "spec")
2820        alias = self.sql(expression, "alias")
2821        over = self.sql(expression, "over") or "OVER"
2822
2823        this = f"{this} {'AS' if expression.arg_key == 'windows' else over}"
2824
2825        first = expression.args.get("first")
2826        if first is None:
2827            first = ""
2828        else:
2829            first = "FIRST" if first else "LAST"
2830
2831        if not partition and not order and not spec and alias:
2832            return f"{this} {alias}"
2833
2834        args = self.format_args(
2835            *[arg for arg in (alias, first, partition, order, spec) if arg], sep=" "
2836        )
2837        return f"{this} ({args})"
2838
2839    def partition_by_sql(self, expression: exp.Window | exp.MatchRecognize) -> str:
2840        partition = self.expressions(expression, key="partition_by", flat=True)
2841        return f"PARTITION BY {partition}" if partition else ""
2842
2843    def windowspec_sql(self, expression: exp.WindowSpec) -> str:
2844        kind = self.sql(expression, "kind")
2845        start = csv(self.sql(expression, "start"), self.sql(expression, "start_side"), sep=" ")
2846        end = (
2847            csv(self.sql(expression, "end"), self.sql(expression, "end_side"), sep=" ")
2848            or "CURRENT ROW"
2849        )
2850
2851        window_spec = f"{kind} BETWEEN {start} AND {end}"
2852
2853        exclude = self.sql(expression, "exclude")
2854        if exclude:
2855            if self.SUPPORTS_WINDOW_EXCLUDE:
2856                window_spec += f" EXCLUDE {exclude}"
2857            else:
2858                self.unsupported("EXCLUDE clause is not supported in the WINDOW clause")
2859
2860        return window_spec
2861
2862    def withingroup_sql(self, expression: exp.WithinGroup) -> str:
2863        this = self.sql(expression, "this")
2864        expression_sql = self.sql(expression, "expression")[1:]  # order has a leading space
2865        return f"{this} WITHIN GROUP ({expression_sql})"
2866
2867    def between_sql(self, expression: exp.Between) -> str:
2868        this = self.sql(expression, "this")
2869        low = self.sql(expression, "low")
2870        high = self.sql(expression, "high")
2871        symmetric = expression.args.get("symmetric")
2872
2873        if symmetric and not self.SUPPORTS_BETWEEN_FLAGS:
2874            return f"({this} BETWEEN {low} AND {high} OR {this} BETWEEN {high} AND {low})"
2875
2876        flag = (
2877            " SYMMETRIC"
2878            if symmetric
2879            else " ASYMMETRIC"
2880            if symmetric is False and self.SUPPORTS_BETWEEN_FLAGS
2881            else ""  # silently drop ASYMMETRIC – semantics identical
2882        )
2883        return f"{this} BETWEEN{flag} {low} AND {high}"
2884
2885    def bracket_offset_expressions(
2886        self, expression: exp.Bracket, index_offset: t.Optional[int] = None
2887    ) -> t.List[exp.Expression]:
2888        return apply_index_offset(
2889            expression.this,
2890            expression.expressions,
2891            (index_offset or self.dialect.INDEX_OFFSET) - expression.args.get("offset", 0),
2892            dialect=self.dialect,
2893        )
2894
2895    def bracket_sql(self, expression: exp.Bracket) -> str:
2896        expressions = self.bracket_offset_expressions(expression)
2897        expressions_sql = ", ".join(self.sql(e) for e in expressions)
2898        return f"{self.sql(expression, 'this')}[{expressions_sql}]"
2899
2900    def all_sql(self, expression: exp.All) -> str:
2901        return f"ALL {self.wrap(expression)}"
2902
2903    def any_sql(self, expression: exp.Any) -> str:
2904        this = self.sql(expression, "this")
2905        if isinstance(expression.this, (*exp.UNWRAPPED_QUERIES, exp.Paren)):
2906            if isinstance(expression.this, exp.UNWRAPPED_QUERIES):
2907                this = self.wrap(this)
2908            return f"ANY{this}"
2909        return f"ANY {this}"
2910
2911    def exists_sql(self, expression: exp.Exists) -> str:
2912        return f"EXISTS{self.wrap(expression)}"
2913
2914    def case_sql(self, expression: exp.Case) -> str:
2915        this = self.sql(expression, "this")
2916        statements = [f"CASE {this}" if this else "CASE"]
2917
2918        for e in expression.args["ifs"]:
2919            statements.append(f"WHEN {self.sql(e, 'this')}")
2920            statements.append(f"THEN {self.sql(e, 'true')}")
2921
2922        default = self.sql(expression, "default")
2923
2924        if default:
2925            statements.append(f"ELSE {default}")
2926
2927        statements.append("END")
2928
2929        if self.pretty and self.too_wide(statements):
2930            return self.indent("\n".join(statements), skip_first=True, skip_last=True)
2931
2932        return " ".join(statements)
2933
2934    def constraint_sql(self, expression: exp.Constraint) -> str:
2935        this = self.sql(expression, "this")
2936        expressions = self.expressions(expression, flat=True)
2937        return f"CONSTRAINT {this} {expressions}"
2938
2939    def nextvaluefor_sql(self, expression: exp.NextValueFor) -> str:
2940        order = expression.args.get("order")
2941        order = f" OVER ({self.order_sql(order, flat=True)})" if order else ""
2942        return f"NEXT VALUE FOR {self.sql(expression, 'this')}{order}"
2943
2944    def extract_sql(self, expression: exp.Extract) -> str:
2945        from sqlglot.dialects.dialect import map_date_part
2946
2947        this = (
2948            map_date_part(expression.this, self.dialect)
2949            if self.NORMALIZE_EXTRACT_DATE_PARTS
2950            else expression.this
2951        )
2952        this_sql = self.sql(this) if self.EXTRACT_ALLOWS_QUOTES else this.name
2953        expression_sql = self.sql(expression, "expression")
2954
2955        return f"EXTRACT({this_sql} FROM {expression_sql})"
2956
2957    def trim_sql(self, expression: exp.Trim) -> str:
2958        trim_type = self.sql(expression, "position")
2959
2960        if trim_type == "LEADING":
2961            func_name = "LTRIM"
2962        elif trim_type == "TRAILING":
2963            func_name = "RTRIM"
2964        else:
2965            func_name = "TRIM"
2966
2967        return self.func(func_name, expression.this, expression.expression)
2968
2969    def convert_concat_args(self, expression: exp.Concat | exp.ConcatWs) -> t.List[exp.Expression]:
2970        args = expression.expressions
2971        if isinstance(expression, exp.ConcatWs):
2972            args = args[1:]  # Skip the delimiter
2973
2974        if self.dialect.STRICT_STRING_CONCAT and expression.args.get("safe"):
2975            args = [exp.cast(e, exp.DataType.Type.TEXT) for e in args]
2976
2977        if not self.dialect.CONCAT_COALESCE and expression.args.get("coalesce"):
2978            args = [exp.func("coalesce", e, exp.Literal.string("")) for e in args]
2979
2980        return args
2981
2982    def concat_sql(self, expression: exp.Concat) -> str:
2983        expressions = self.convert_concat_args(expression)
2984
2985        # Some dialects don't allow a single-argument CONCAT call
2986        if not self.SUPPORTS_SINGLE_ARG_CONCAT and len(expressions) == 1:
2987            return self.sql(expressions[0])
2988
2989        return self.func("CONCAT", *expressions)
2990
2991    def concatws_sql(self, expression: exp.ConcatWs) -> str:
2992        return self.func(
2993            "CONCAT_WS", seq_get(expression.expressions, 0), *self.convert_concat_args(expression)
2994        )
2995
2996    def check_sql(self, expression: exp.Check) -> str:
2997        this = self.sql(expression, key="this")
2998        return f"CHECK ({this})"
2999
3000    def foreignkey_sql(self, expression: exp.ForeignKey) -> str:
3001        expressions = self.expressions(expression, flat=True)
3002        expressions = f" ({expressions})" if expressions else ""
3003        reference = self.sql(expression, "reference")
3004        reference = f" {reference}" if reference else ""
3005        delete = self.sql(expression, "delete")
3006        delete = f" ON DELETE {delete}" if delete else ""
3007        update = self.sql(expression, "update")
3008        update = f" ON UPDATE {update}" if update else ""
3009        options = self.expressions(expression, key="options", flat=True, sep=" ")
3010        options = f" {options}" if options else ""
3011        return f"FOREIGN KEY{expressions}{reference}{delete}{update}{options}"
3012
3013    def primarykey_sql(self, expression: exp.PrimaryKey) -> str:
3014        expressions = self.expressions(expression, flat=True)
3015        include = self.sql(expression, "include")
3016        options = self.expressions(expression, key="options", flat=True, sep=" ")
3017        options = f" {options}" if options else ""
3018        return f"PRIMARY KEY ({expressions}){include}{options}"
3019
3020    def if_sql(self, expression: exp.If) -> str:
3021        return self.case_sql(exp.Case(ifs=[expression], default=expression.args.get("false")))
3022
3023    def matchagainst_sql(self, expression: exp.MatchAgainst) -> str:
3024        modifier = expression.args.get("modifier")
3025        modifier = f" {modifier}" if modifier else ""
3026        return f"{self.func('MATCH', *expression.expressions)} AGAINST({self.sql(expression, 'this')}{modifier})"
3027
3028    def jsonkeyvalue_sql(self, expression: exp.JSONKeyValue) -> str:
3029        return f"{self.sql(expression, 'this')}{self.JSON_KEY_VALUE_PAIR_SEP} {self.sql(expression, 'expression')}"
3030
3031    def jsonpath_sql(self, expression: exp.JSONPath) -> str:
3032        path = self.expressions(expression, sep="", flat=True).lstrip(".")
3033
3034        if expression.args.get("escape"):
3035            path = self.escape_str(path)
3036
3037        if self.QUOTE_JSON_PATH:
3038            path = f"{self.dialect.QUOTE_START}{path}{self.dialect.QUOTE_END}"
3039
3040        return path
3041
3042    def json_path_part(self, expression: int | str | exp.JSONPathPart) -> str:
3043        if isinstance(expression, exp.JSONPathPart):
3044            transform = self.TRANSFORMS.get(expression.__class__)
3045            if not callable(transform):
3046                self.unsupported(f"Unsupported JSONPathPart type {expression.__class__.__name__}")
3047                return ""
3048
3049            return transform(self, expression)
3050
3051        if isinstance(expression, int):
3052            return str(expression)
3053
3054        if self._quote_json_path_key_using_brackets and self.JSON_PATH_SINGLE_QUOTE_ESCAPE:
3055            escaped = expression.replace("'", "\\'")
3056            escaped = f"\\'{expression}\\'"
3057        else:
3058            escaped = expression.replace('"', '\\"')
3059            escaped = f'"{escaped}"'
3060
3061        return escaped
3062
3063    def formatjson_sql(self, expression: exp.FormatJson) -> str:
3064        return f"{self.sql(expression, 'this')} FORMAT JSON"
3065
3066    def formatphrase_sql(self, expression: exp.FormatPhrase) -> str:
3067        # Output the Teradata column FORMAT override.
3068        # https://docs.teradata.com/r/Enterprise_IntelliFlex_VMware/SQL-Data-Types-and-Literals/Data-Type-Formats-and-Format-Phrases/FORMAT
3069        this = self.sql(expression, "this")
3070        fmt = self.sql(expression, "format")
3071        return f"{this} (FORMAT {fmt})"
3072
3073    def jsonobject_sql(self, expression: exp.JSONObject | exp.JSONObjectAgg) -> str:
3074        null_handling = expression.args.get("null_handling")
3075        null_handling = f" {null_handling}" if null_handling else ""
3076
3077        unique_keys = expression.args.get("unique_keys")
3078        if unique_keys is not None:
3079            unique_keys = f" {'WITH' if unique_keys else 'WITHOUT'} UNIQUE KEYS"
3080        else:
3081            unique_keys = ""
3082
3083        return_type = self.sql(expression, "return_type")
3084        return_type = f" RETURNING {return_type}" if return_type else ""
3085        encoding = self.sql(expression, "encoding")
3086        encoding = f" ENCODING {encoding}" if encoding else ""
3087
3088        return self.func(
3089            "JSON_OBJECT" if isinstance(expression, exp.JSONObject) else "JSON_OBJECTAGG",
3090            *expression.expressions,
3091            suffix=f"{null_handling}{unique_keys}{return_type}{encoding})",
3092        )
3093
3094    def jsonobjectagg_sql(self, expression: exp.JSONObjectAgg) -> str:
3095        return self.jsonobject_sql(expression)
3096
3097    def jsonarray_sql(self, expression: exp.JSONArray) -> str:
3098        null_handling = expression.args.get("null_handling")
3099        null_handling = f" {null_handling}" if null_handling else ""
3100        return_type = self.sql(expression, "return_type")
3101        return_type = f" RETURNING {return_type}" if return_type else ""
3102        strict = " STRICT" if expression.args.get("strict") else ""
3103        return self.func(
3104            "JSON_ARRAY", *expression.expressions, suffix=f"{null_handling}{return_type}{strict})"
3105        )
3106
3107    def jsonarrayagg_sql(self, expression: exp.JSONArrayAgg) -> str:
3108        this = self.sql(expression, "this")
3109        order = self.sql(expression, "order")
3110        null_handling = expression.args.get("null_handling")
3111        null_handling = f" {null_handling}" if null_handling else ""
3112        return_type = self.sql(expression, "return_type")
3113        return_type = f" RETURNING {return_type}" if return_type else ""
3114        strict = " STRICT" if expression.args.get("strict") else ""
3115        return self.func(
3116            "JSON_ARRAYAGG",
3117            this,
3118            suffix=f"{order}{null_handling}{return_type}{strict})",
3119        )
3120
3121    def jsoncolumndef_sql(self, expression: exp.JSONColumnDef) -> str:
3122        path = self.sql(expression, "path")
3123        path = f" PATH {path}" if path else ""
3124        nested_schema = self.sql(expression, "nested_schema")
3125
3126        if nested_schema:
3127            return f"NESTED{path} {nested_schema}"
3128
3129        this = self.sql(expression, "this")
3130        kind = self.sql(expression, "kind")
3131        kind = f" {kind}" if kind else ""
3132        return f"{this}{kind}{path}"
3133
3134    def jsonschema_sql(self, expression: exp.JSONSchema) -> str:
3135        return self.func("COLUMNS", *expression.expressions)
3136
3137    def jsontable_sql(self, expression: exp.JSONTable) -> str:
3138        this = self.sql(expression, "this")
3139        path = self.sql(expression, "path")
3140        path = f", {path}" if path else ""
3141        error_handling = expression.args.get("error_handling")
3142        error_handling = f" {error_handling}" if error_handling else ""
3143        empty_handling = expression.args.get("empty_handling")
3144        empty_handling = f" {empty_handling}" if empty_handling else ""
3145        schema = self.sql(expression, "schema")
3146        return self.func(
3147            "JSON_TABLE", this, suffix=f"{path}{error_handling}{empty_handling} {schema})"
3148        )
3149
3150    def openjsoncolumndef_sql(self, expression: exp.OpenJSONColumnDef) -> str:
3151        this = self.sql(expression, "this")
3152        kind = self.sql(expression, "kind")
3153        path = self.sql(expression, "path")
3154        path = f" {path}" if path else ""
3155        as_json = " AS JSON" if expression.args.get("as_json") else ""
3156        return f"{this} {kind}{path}{as_json}"
3157
3158    def openjson_sql(self, expression: exp.OpenJSON) -> str:
3159        this = self.sql(expression, "this")
3160        path = self.sql(expression, "path")
3161        path = f", {path}" if path else ""
3162        expressions = self.expressions(expression)
3163        with_ = (
3164            f" WITH ({self.seg(self.indent(expressions), sep='')}{self.seg(')', sep='')}"
3165            if expressions
3166            else ""
3167        )
3168        return f"OPENJSON({this}{path}){with_}"
3169
3170    def in_sql(self, expression: exp.In) -> str:
3171        query = expression.args.get("query")
3172        unnest = expression.args.get("unnest")
3173        field = expression.args.get("field")
3174        is_global = " GLOBAL" if expression.args.get("is_global") else ""
3175
3176        if query:
3177            in_sql = self.sql(query)
3178        elif unnest:
3179            in_sql = self.in_unnest_op(unnest)
3180        elif field:
3181            in_sql = self.sql(field)
3182        else:
3183            in_sql = f"({self.expressions(expression, dynamic=True, new_line=True, skip_first=True, skip_last=True)})"
3184
3185        return f"{self.sql(expression, 'this')}{is_global} IN {in_sql}"
3186
3187    def in_unnest_op(self, unnest: exp.Unnest) -> str:
3188        return f"(SELECT {self.sql(unnest)})"
3189
3190    def interval_sql(self, expression: exp.Interval) -> str:
3191        unit = self.sql(expression, "unit")
3192        if not self.INTERVAL_ALLOWS_PLURAL_FORM:
3193            unit = self.TIME_PART_SINGULARS.get(unit, unit)
3194        unit = f" {unit}" if unit else ""
3195
3196        if self.SINGLE_STRING_INTERVAL:
3197            this = expression.this.name if expression.this else ""
3198            return f"INTERVAL '{this}{unit}'" if this else f"INTERVAL{unit}"
3199
3200        this = self.sql(expression, "this")
3201        if this:
3202            unwrapped = isinstance(expression.this, self.UNWRAPPED_INTERVAL_VALUES)
3203            this = f" {this}" if unwrapped else f" ({this})"
3204
3205        return f"INTERVAL{this}{unit}"
3206
3207    def return_sql(self, expression: exp.Return) -> str:
3208        return f"RETURN {self.sql(expression, 'this')}"
3209
3210    def reference_sql(self, expression: exp.Reference) -> str:
3211        this = self.sql(expression, "this")
3212        expressions = self.expressions(expression, flat=True)
3213        expressions = f"({expressions})" if expressions else ""
3214        options = self.expressions(expression, key="options", flat=True, sep=" ")
3215        options = f" {options}" if options else ""
3216        return f"REFERENCES {this}{expressions}{options}"
3217
3218    def anonymous_sql(self, expression: exp.Anonymous) -> str:
3219        # We don't normalize qualified functions such as a.b.foo(), because they can be case-sensitive
3220        parent = expression.parent
3221        is_qualified = isinstance(parent, exp.Dot) and expression is parent.expression
3222        return self.func(
3223            self.sql(expression, "this"), *expression.expressions, normalize=not is_qualified
3224        )
3225
3226    def paren_sql(self, expression: exp.Paren) -> str:
3227        sql = self.seg(self.indent(self.sql(expression, "this")), sep="")
3228        return f"({sql}{self.seg(')', sep='')}"
3229
3230    def neg_sql(self, expression: exp.Neg) -> str:
3231        # This makes sure we don't convert "- - 5" to "--5", which is a comment
3232        this_sql = self.sql(expression, "this")
3233        sep = " " if this_sql[0] == "-" else ""
3234        return f"-{sep}{this_sql}"
3235
3236    def not_sql(self, expression: exp.Not) -> str:
3237        return f"NOT {self.sql(expression, 'this')}"
3238
3239    def alias_sql(self, expression: exp.Alias) -> str:
3240        alias = self.sql(expression, "alias")
3241        alias = f" AS {alias}" if alias else ""
3242        return f"{self.sql(expression, 'this')}{alias}"
3243
3244    def pivotalias_sql(self, expression: exp.PivotAlias) -> str:
3245        alias = expression.args["alias"]
3246
3247        parent = expression.parent
3248        pivot = parent and parent.parent
3249
3250        if isinstance(pivot, exp.Pivot) and pivot.unpivot:
3251            identifier_alias = isinstance(alias, exp.Identifier)
3252            literal_alias = isinstance(alias, exp.Literal)
3253
3254            if identifier_alias and not self.UNPIVOT_ALIASES_ARE_IDENTIFIERS:
3255                alias.replace(exp.Literal.string(alias.output_name))
3256            elif not identifier_alias and literal_alias and self.UNPIVOT_ALIASES_ARE_IDENTIFIERS:
3257                alias.replace(exp.to_identifier(alias.output_name))
3258
3259        return self.alias_sql(expression)
3260
3261    def aliases_sql(self, expression: exp.Aliases) -> str:
3262        return f"{self.sql(expression, 'this')} AS ({self.expressions(expression, flat=True)})"
3263
3264    def atindex_sql(self, expression: exp.AtTimeZone) -> str:
3265        this = self.sql(expression, "this")
3266        index = self.sql(expression, "expression")
3267        return f"{this} AT {index}"
3268
3269    def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
3270        this = self.sql(expression, "this")
3271        zone = self.sql(expression, "zone")
3272        return f"{this} AT TIME ZONE {zone}"
3273
3274    def fromtimezone_sql(self, expression: exp.FromTimeZone) -> str:
3275        this = self.sql(expression, "this")
3276        zone = self.sql(expression, "zone")
3277        return f"{this} AT TIME ZONE {zone} AT TIME ZONE 'UTC'"
3278
3279    def add_sql(self, expression: exp.Add) -> str:
3280        return self.binary(expression, "+")
3281
3282    def and_sql(
3283        self, expression: exp.And, stack: t.Optional[t.List[str | exp.Expression]] = None
3284    ) -> str:
3285        return self.connector_sql(expression, "AND", stack)
3286
3287    def or_sql(
3288        self, expression: exp.Or, stack: t.Optional[t.List[str | exp.Expression]] = None
3289    ) -> str:
3290        return self.connector_sql(expression, "OR", stack)
3291
3292    def xor_sql(
3293        self, expression: exp.Xor, stack: t.Optional[t.List[str | exp.Expression]] = None
3294    ) -> str:
3295        return self.connector_sql(expression, "XOR", stack)
3296
3297    def connector_sql(
3298        self,
3299        expression: exp.Connector,
3300        op: str,
3301        stack: t.Optional[t.List[str | exp.Expression]] = None,
3302    ) -> str:
3303        if stack is not None:
3304            if expression.expressions:
3305                stack.append(self.expressions(expression, sep=f" {op} "))
3306            else:
3307                stack.append(expression.right)
3308                if expression.comments and self.comments:
3309                    for comment in expression.comments:
3310                        if comment:
3311                            op += f" /*{self.sanitize_comment(comment)}*/"
3312                stack.extend((op, expression.left))
3313            return op
3314
3315        stack = [expression]
3316        sqls: t.List[str] = []
3317        ops = set()
3318
3319        while stack:
3320            node = stack.pop()
3321            if isinstance(node, exp.Connector):
3322                ops.add(getattr(self, f"{node.key}_sql")(node, stack))
3323            else:
3324                sql = self.sql(node)
3325                if sqls and sqls[-1] in ops:
3326                    sqls[-1] += f" {sql}"
3327                else:
3328                    sqls.append(sql)
3329
3330        sep = "\n" if self.pretty and self.too_wide(sqls) else " "
3331        return sep.join(sqls)
3332
3333    def bitwiseand_sql(self, expression: exp.BitwiseAnd) -> str:
3334        return self.binary(expression, "&")
3335
3336    def bitwiseleftshift_sql(self, expression: exp.BitwiseLeftShift) -> str:
3337        return self.binary(expression, "<<")
3338
3339    def bitwisenot_sql(self, expression: exp.BitwiseNot) -> str:
3340        return f"~{self.sql(expression, 'this')}"
3341
3342    def bitwiseor_sql(self, expression: exp.BitwiseOr) -> str:
3343        return self.binary(expression, "|")
3344
3345    def bitwiserightshift_sql(self, expression: exp.BitwiseRightShift) -> str:
3346        return self.binary(expression, ">>")
3347
3348    def bitwisexor_sql(self, expression: exp.BitwiseXor) -> str:
3349        return self.binary(expression, "^")
3350
3351    def cast_sql(self, expression: exp.Cast, safe_prefix: t.Optional[str] = None) -> str:
3352        format_sql = self.sql(expression, "format")
3353        format_sql = f" FORMAT {format_sql}" if format_sql else ""
3354        to_sql = self.sql(expression, "to")
3355        to_sql = f" {to_sql}" if to_sql else ""
3356        action = self.sql(expression, "action")
3357        action = f" {action}" if action else ""
3358        default = self.sql(expression, "default")
3359        default = f" DEFAULT {default} ON CONVERSION ERROR" if default else ""
3360        return f"{safe_prefix or ''}CAST({self.sql(expression, 'this')} AS{to_sql}{default}{format_sql}{action})"
3361
3362    def currentdate_sql(self, expression: exp.CurrentDate) -> str:
3363        zone = self.sql(expression, "this")
3364        return f"CURRENT_DATE({zone})" if zone else "CURRENT_DATE"
3365
3366    def collate_sql(self, expression: exp.Collate) -> str:
3367        if self.COLLATE_IS_FUNC:
3368            return self.function_fallback_sql(expression)
3369        return self.binary(expression, "COLLATE")
3370
3371    def command_sql(self, expression: exp.Command) -> str:
3372        return f"{self.sql(expression, 'this')} {expression.text('expression').strip()}"
3373
3374    def comment_sql(self, expression: exp.Comment) -> str:
3375        this = self.sql(expression, "this")
3376        kind = expression.args["kind"]
3377        materialized = " MATERIALIZED" if expression.args.get("materialized") else ""
3378        exists_sql = " IF EXISTS " if expression.args.get("exists") else " "
3379        expression_sql = self.sql(expression, "expression")
3380        return f"COMMENT{exists_sql}ON{materialized} {kind} {this} IS {expression_sql}"
3381
3382    def mergetreettlaction_sql(self, expression: exp.MergeTreeTTLAction) -> str:
3383        this = self.sql(expression, "this")
3384        delete = " DELETE" if expression.args.get("delete") else ""
3385        recompress = self.sql(expression, "recompress")
3386        recompress = f" RECOMPRESS {recompress}" if recompress else ""
3387        to_disk = self.sql(expression, "to_disk")
3388        to_disk = f" TO DISK {to_disk}" if to_disk else ""
3389        to_volume = self.sql(expression, "to_volume")
3390        to_volume = f" TO VOLUME {to_volume}" if to_volume else ""
3391        return f"{this}{delete}{recompress}{to_disk}{to_volume}"
3392
3393    def mergetreettl_sql(self, expression: exp.MergeTreeTTL) -> str:
3394        where = self.sql(expression, "where")
3395        group = self.sql(expression, "group")
3396        aggregates = self.expressions(expression, key="aggregates")
3397        aggregates = self.seg("SET") + self.seg(aggregates) if aggregates else ""
3398
3399        if not (where or group or aggregates) and len(expression.expressions) == 1:
3400            return f"TTL {self.expressions(expression, flat=True)}"
3401
3402        return f"TTL{self.seg(self.expressions(expression))}{where}{group}{aggregates}"
3403
3404    def transaction_sql(self, expression: exp.Transaction) -> str:
3405        return "BEGIN"
3406
3407    def commit_sql(self, expression: exp.Commit) -> str:
3408        chain = expression.args.get("chain")
3409        if chain is not None:
3410            chain = " AND CHAIN" if chain else " AND NO CHAIN"
3411
3412        return f"COMMIT{chain or ''}"
3413
3414    def rollback_sql(self, expression: exp.Rollback) -> str:
3415        savepoint = expression.args.get("savepoint")
3416        savepoint = f" TO {savepoint}" if savepoint else ""
3417        return f"ROLLBACK{savepoint}"
3418
3419    def altercolumn_sql(self, expression: exp.AlterColumn) -> str:
3420        this = self.sql(expression, "this")
3421
3422        dtype = self.sql(expression, "dtype")
3423        if dtype:
3424            collate = self.sql(expression, "collate")
3425            collate = f" COLLATE {collate}" if collate else ""
3426            using = self.sql(expression, "using")
3427            using = f" USING {using}" if using else ""
3428            alter_set_type = self.ALTER_SET_TYPE + " " if self.ALTER_SET_TYPE else ""
3429            return f"ALTER COLUMN {this} {alter_set_type}{dtype}{collate}{using}"
3430
3431        default = self.sql(expression, "default")
3432        if default:
3433            return f"ALTER COLUMN {this} SET DEFAULT {default}"
3434
3435        comment = self.sql(expression, "comment")
3436        if comment:
3437            return f"ALTER COLUMN {this} COMMENT {comment}"
3438
3439        visible = expression.args.get("visible")
3440        if visible:
3441            return f"ALTER COLUMN {this} SET {visible}"
3442
3443        allow_null = expression.args.get("allow_null")
3444        drop = expression.args.get("drop")
3445
3446        if not drop and not allow_null:
3447            self.unsupported("Unsupported ALTER COLUMN syntax")
3448
3449        if allow_null is not None:
3450            keyword = "DROP" if drop else "SET"
3451            return f"ALTER COLUMN {this} {keyword} NOT NULL"
3452
3453        return f"ALTER COLUMN {this} DROP DEFAULT"
3454
3455    def alterindex_sql(self, expression: exp.AlterIndex) -> str:
3456        this = self.sql(expression, "this")
3457
3458        visible = expression.args.get("visible")
3459        visible_sql = "VISIBLE" if visible else "INVISIBLE"
3460
3461        return f"ALTER INDEX {this} {visible_sql}"
3462
3463    def alterdiststyle_sql(self, expression: exp.AlterDistStyle) -> str:
3464        this = self.sql(expression, "this")
3465        if not isinstance(expression.this, exp.Var):
3466            this = f"KEY DISTKEY {this}"
3467        return f"ALTER DISTSTYLE {this}"
3468
3469    def altersortkey_sql(self, expression: exp.AlterSortKey) -> str:
3470        compound = " COMPOUND" if expression.args.get("compound") else ""
3471        this = self.sql(expression, "this")
3472        expressions = self.expressions(expression, flat=True)
3473        expressions = f"({expressions})" if expressions else ""
3474        return f"ALTER{compound} SORTKEY {this or expressions}"
3475
3476    def alterrename_sql(self, expression: exp.AlterRename) -> str:
3477        if not self.RENAME_TABLE_WITH_DB:
3478            # Remove db from tables
3479            expression = expression.transform(
3480                lambda n: exp.table_(n.this) if isinstance(n, exp.Table) else n
3481            ).assert_is(exp.AlterRename)
3482        this = self.sql(expression, "this")
3483        return f"RENAME TO {this}"
3484
3485    def renamecolumn_sql(self, expression: exp.RenameColumn) -> str:
3486        exists = " IF EXISTS" if expression.args.get("exists") else ""
3487        old_column = self.sql(expression, "this")
3488        new_column = self.sql(expression, "to")
3489        return f"RENAME COLUMN{exists} {old_column} TO {new_column}"
3490
3491    def alterset_sql(self, expression: exp.AlterSet) -> str:
3492        exprs = self.expressions(expression, flat=True)
3493        if self.ALTER_SET_WRAPPED:
3494            exprs = f"({exprs})"
3495
3496        return f"SET {exprs}"
3497
3498    def alter_sql(self, expression: exp.Alter) -> str:
3499        actions = expression.args["actions"]
3500
3501        if not self.dialect.ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN and isinstance(
3502            actions[0], exp.ColumnDef
3503        ):
3504            actions_sql = self.expressions(expression, key="actions", flat=True)
3505            actions_sql = f"ADD {actions_sql}"
3506        else:
3507            actions_list = []
3508            for action in actions:
3509                if isinstance(action, (exp.ColumnDef, exp.Schema)):
3510                    action_sql = self.add_column_sql(action)
3511                else:
3512                    action_sql = self.sql(action)
3513                    if isinstance(action, exp.Query):
3514                        action_sql = f"AS {action_sql}"
3515
3516                actions_list.append(action_sql)
3517
3518            actions_sql = self.format_args(*actions_list).lstrip("\n")
3519
3520        exists = " IF EXISTS" if expression.args.get("exists") else ""
3521        on_cluster = self.sql(expression, "cluster")
3522        on_cluster = f" {on_cluster}" if on_cluster else ""
3523        only = " ONLY" if expression.args.get("only") else ""
3524        options = self.expressions(expression, key="options")
3525        options = f", {options}" if options else ""
3526        kind = self.sql(expression, "kind")
3527        not_valid = " NOT VALID" if expression.args.get("not_valid") else ""
3528
3529        return f"ALTER {kind}{exists}{only} {self.sql(expression, 'this')}{on_cluster}{self.sep()}{actions_sql}{not_valid}{options}"
3530
3531    def add_column_sql(self, expression: exp.Expression) -> str:
3532        sql = self.sql(expression)
3533        if isinstance(expression, exp.Schema):
3534            column_text = " COLUMNS"
3535        elif isinstance(expression, exp.ColumnDef) and self.ALTER_TABLE_INCLUDE_COLUMN_KEYWORD:
3536            column_text = " COLUMN"
3537        else:
3538            column_text = ""
3539
3540        return f"ADD{column_text} {sql}"
3541
3542    def droppartition_sql(self, expression: exp.DropPartition) -> str:
3543        expressions = self.expressions(expression)
3544        exists = " IF EXISTS " if expression.args.get("exists") else " "
3545        return f"DROP{exists}{expressions}"
3546
3547    def addconstraint_sql(self, expression: exp.AddConstraint) -> str:
3548        return f"ADD {self.expressions(expression, indent=False)}"
3549
3550    def addpartition_sql(self, expression: exp.AddPartition) -> str:
3551        exists = "IF NOT EXISTS " if expression.args.get("exists") else ""
3552        return f"ADD {exists}{self.sql(expression.this)}"
3553
3554    def distinct_sql(self, expression: exp.Distinct) -> str:
3555        this = self.expressions(expression, flat=True)
3556
3557        if not self.MULTI_ARG_DISTINCT and len(expression.expressions) > 1:
3558            case = exp.case()
3559            for arg in expression.expressions:
3560                case = case.when(arg.is_(exp.null()), exp.null())
3561            this = self.sql(case.else_(f"({this})"))
3562
3563        this = f" {this}" if this else ""
3564
3565        on = self.sql(expression, "on")
3566        on = f" ON {on}" if on else ""
3567        return f"DISTINCT{this}{on}"
3568
3569    def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
3570        return self._embed_ignore_nulls(expression, "IGNORE NULLS")
3571
3572    def respectnulls_sql(self, expression: exp.RespectNulls) -> str:
3573        return self._embed_ignore_nulls(expression, "RESPECT NULLS")
3574
3575    def havingmax_sql(self, expression: exp.HavingMax) -> str:
3576        this_sql = self.sql(expression, "this")
3577        expression_sql = self.sql(expression, "expression")
3578        kind = "MAX" if expression.args.get("max") else "MIN"
3579        return f"{this_sql} HAVING {kind} {expression_sql}"
3580
3581    def intdiv_sql(self, expression: exp.IntDiv) -> str:
3582        return self.sql(
3583            exp.Cast(
3584                this=exp.Div(this=expression.this, expression=expression.expression),
3585                to=exp.DataType(this=exp.DataType.Type.INT),
3586            )
3587        )
3588
3589    def dpipe_sql(self, expression: exp.DPipe) -> str:
3590        if self.dialect.STRICT_STRING_CONCAT and expression.args.get("safe"):
3591            return self.func(
3592                "CONCAT", *(exp.cast(e, exp.DataType.Type.TEXT) for e in expression.flatten())
3593            )
3594        return self.binary(expression, "||")
3595
3596    def div_sql(self, expression: exp.Div) -> str:
3597        l, r = expression.left, expression.right
3598
3599        if not self.dialect.SAFE_DIVISION and expression.args.get("safe"):
3600            r.replace(exp.Nullif(this=r.copy(), expression=exp.Literal.number(0)))
3601
3602        if self.dialect.TYPED_DIVISION and not expression.args.get("typed"):
3603            if not l.is_type(*exp.DataType.REAL_TYPES) and not r.is_type(*exp.DataType.REAL_TYPES):
3604                l.replace(exp.cast(l.copy(), to=exp.DataType.Type.DOUBLE))
3605
3606        elif not self.dialect.TYPED_DIVISION and expression.args.get("typed"):
3607            if l.is_type(*exp.DataType.INTEGER_TYPES) and r.is_type(*exp.DataType.INTEGER_TYPES):
3608                return self.sql(
3609                    exp.cast(
3610                        l / r,
3611                        to=exp.DataType.Type.BIGINT,
3612                    )
3613                )
3614
3615        return self.binary(expression, "/")
3616
3617    def safedivide_sql(self, expression: exp.SafeDivide) -> str:
3618        n = exp._wrap(expression.this, exp.Binary)
3619        d = exp._wrap(expression.expression, exp.Binary)
3620        return self.sql(exp.If(this=d.neq(0), true=n / d, false=exp.Null()))
3621
3622    def overlaps_sql(self, expression: exp.Overlaps) -> str:
3623        return self.binary(expression, "OVERLAPS")
3624
3625    def distance_sql(self, expression: exp.Distance) -> str:
3626        return self.binary(expression, "<->")
3627
3628    def dot_sql(self, expression: exp.Dot) -> str:
3629        return f"{self.sql(expression, 'this')}.{self.sql(expression, 'expression')}"
3630
3631    def eq_sql(self, expression: exp.EQ) -> str:
3632        return self.binary(expression, "=")
3633
3634    def propertyeq_sql(self, expression: exp.PropertyEQ) -> str:
3635        return self.binary(expression, ":=")
3636
3637    def escape_sql(self, expression: exp.Escape) -> str:
3638        return self.binary(expression, "ESCAPE")
3639
3640    def glob_sql(self, expression: exp.Glob) -> str:
3641        return self.binary(expression, "GLOB")
3642
3643    def gt_sql(self, expression: exp.GT) -> str:
3644        return self.binary(expression, ">")
3645
3646    def gte_sql(self, expression: exp.GTE) -> str:
3647        return self.binary(expression, ">=")
3648
3649    def ilike_sql(self, expression: exp.ILike) -> str:
3650        return self.binary(expression, "ILIKE")
3651
3652    def ilikeany_sql(self, expression: exp.ILikeAny) -> str:
3653        return self.binary(expression, "ILIKE ANY")
3654
3655    def is_sql(self, expression: exp.Is) -> str:
3656        if not self.IS_BOOL_ALLOWED and isinstance(expression.expression, exp.Boolean):
3657            return self.sql(
3658                expression.this if expression.expression.this else exp.not_(expression.this)
3659            )
3660        return self.binary(expression, "IS")
3661
3662    def like_sql(self, expression: exp.Like) -> str:
3663        return self.binary(expression, "LIKE")
3664
3665    def likeany_sql(self, expression: exp.LikeAny) -> str:
3666        return self.binary(expression, "LIKE ANY")
3667
3668    def similarto_sql(self, expression: exp.SimilarTo) -> str:
3669        return self.binary(expression, "SIMILAR TO")
3670
3671    def lt_sql(self, expression: exp.LT) -> str:
3672        return self.binary(expression, "<")
3673
3674    def lte_sql(self, expression: exp.LTE) -> str:
3675        return self.binary(expression, "<=")
3676
3677    def mod_sql(self, expression: exp.Mod) -> str:
3678        return self.binary(expression, "%")
3679
3680    def mul_sql(self, expression: exp.Mul) -> str:
3681        return self.binary(expression, "*")
3682
3683    def neq_sql(self, expression: exp.NEQ) -> str:
3684        return self.binary(expression, "<>")
3685
3686    def nullsafeeq_sql(self, expression: exp.NullSafeEQ) -> str:
3687        return self.binary(expression, "IS NOT DISTINCT FROM")
3688
3689    def nullsafeneq_sql(self, expression: exp.NullSafeNEQ) -> str:
3690        return self.binary(expression, "IS DISTINCT FROM")
3691
3692    def slice_sql(self, expression: exp.Slice) -> str:
3693        return self.binary(expression, ":")
3694
3695    def sub_sql(self, expression: exp.Sub) -> str:
3696        return self.binary(expression, "-")
3697
3698    def trycast_sql(self, expression: exp.TryCast) -> str:
3699        return self.cast_sql(expression, safe_prefix="TRY_")
3700
3701    def jsoncast_sql(self, expression: exp.JSONCast) -> str:
3702        return self.cast_sql(expression)
3703
3704    def try_sql(self, expression: exp.Try) -> str:
3705        if not self.TRY_SUPPORTED:
3706            self.unsupported("Unsupported TRY function")
3707            return self.sql(expression, "this")
3708
3709        return self.func("TRY", expression.this)
3710
3711    def log_sql(self, expression: exp.Log) -> str:
3712        this = expression.this
3713        expr = expression.expression
3714
3715        if self.dialect.LOG_BASE_FIRST is False:
3716            this, expr = expr, this
3717        elif self.dialect.LOG_BASE_FIRST is None and expr:
3718            if this.name in ("2", "10"):
3719                return self.func(f"LOG{this.name}", expr)
3720
3721            self.unsupported(f"Unsupported logarithm with base {self.sql(this)}")
3722
3723        return self.func("LOG", this, expr)
3724
3725    def use_sql(self, expression: exp.Use) -> str:
3726        kind = self.sql(expression, "kind")
3727        kind = f" {kind}" if kind else ""
3728        this = self.sql(expression, "this") or self.expressions(expression, flat=True)
3729        this = f" {this}" if this else ""
3730        return f"USE{kind}{this}"
3731
3732    def binary(self, expression: exp.Binary, op: str) -> str:
3733        sqls: t.List[str] = []
3734        stack: t.List[t.Union[str, exp.Expression]] = [expression]
3735        binary_type = type(expression)
3736
3737        while stack:
3738            node = stack.pop()
3739
3740            if type(node) is binary_type:
3741                op_func = node.args.get("operator")
3742                if op_func:
3743                    op = f"OPERATOR({self.sql(op_func)})"
3744
3745                stack.append(node.right)
3746                stack.append(f" {self.maybe_comment(op, comments=node.comments)} ")
3747                stack.append(node.left)
3748            else:
3749                sqls.append(self.sql(node))
3750
3751        return "".join(sqls)
3752
3753    def ceil_floor(self, expression: exp.Ceil | exp.Floor) -> str:
3754        to_clause = self.sql(expression, "to")
3755        if to_clause:
3756            return f"{expression.sql_name()}({self.sql(expression, 'this')} TO {to_clause})"
3757
3758        return self.function_fallback_sql(expression)
3759
3760    def function_fallback_sql(self, expression: exp.Func) -> str:
3761        args = []
3762
3763        for key in expression.arg_types:
3764            arg_value = expression.args.get(key)
3765
3766            if isinstance(arg_value, list):
3767                for value in arg_value:
3768                    args.append(value)
3769            elif arg_value is not None:
3770                args.append(arg_value)
3771
3772        if self.dialect.PRESERVE_ORIGINAL_NAMES:
3773            name = (expression._meta and expression.meta.get("name")) or expression.sql_name()
3774        else:
3775            name = expression.sql_name()
3776
3777        return self.func(name, *args)
3778
3779    def func(
3780        self,
3781        name: str,
3782        *args: t.Optional[exp.Expression | str],
3783        prefix: str = "(",
3784        suffix: str = ")",
3785        normalize: bool = True,
3786    ) -> str:
3787        name = self.normalize_func(name) if normalize else name
3788        return f"{name}{prefix}{self.format_args(*args)}{suffix}"
3789
3790    def format_args(self, *args: t.Optional[str | exp.Expression], sep: str = ", ") -> str:
3791        arg_sqls = tuple(
3792            self.sql(arg) for arg in args if arg is not None and not isinstance(arg, bool)
3793        )
3794        if self.pretty and self.too_wide(arg_sqls):
3795            return self.indent(
3796                "\n" + f"{sep.strip()}\n".join(arg_sqls) + "\n", skip_first=True, skip_last=True
3797            )
3798        return sep.join(arg_sqls)
3799
3800    def too_wide(self, args: t.Iterable) -> bool:
3801        return sum(len(arg) for arg in args) > self.max_text_width
3802
3803    def format_time(
3804        self,
3805        expression: exp.Expression,
3806        inverse_time_mapping: t.Optional[t.Dict[str, str]] = None,
3807        inverse_time_trie: t.Optional[t.Dict] = None,
3808    ) -> t.Optional[str]:
3809        return format_time(
3810            self.sql(expression, "format"),
3811            inverse_time_mapping or self.dialect.INVERSE_TIME_MAPPING,
3812            inverse_time_trie or self.dialect.INVERSE_TIME_TRIE,
3813        )
3814
3815    def expressions(
3816        self,
3817        expression: t.Optional[exp.Expression] = None,
3818        key: t.Optional[str] = None,
3819        sqls: t.Optional[t.Collection[str | exp.Expression]] = None,
3820        flat: bool = False,
3821        indent: bool = True,
3822        skip_first: bool = False,
3823        skip_last: bool = False,
3824        sep: str = ", ",
3825        prefix: str = "",
3826        dynamic: bool = False,
3827        new_line: bool = False,
3828    ) -> str:
3829        expressions = expression.args.get(key or "expressions") if expression else sqls
3830
3831        if not expressions:
3832            return ""
3833
3834        if flat:
3835            return sep.join(sql for sql in (self.sql(e) for e in expressions) if sql)
3836
3837        num_sqls = len(expressions)
3838        result_sqls = []
3839
3840        for i, e in enumerate(expressions):
3841            sql = self.sql(e, comment=False)
3842            if not sql:
3843                continue
3844
3845            comments = self.maybe_comment("", e) if isinstance(e, exp.Expression) else ""
3846
3847            if self.pretty:
3848                if self.leading_comma:
3849                    result_sqls.append(f"{sep if i > 0 else ''}{prefix}{sql}{comments}")
3850                else:
3851                    result_sqls.append(
3852                        f"{prefix}{sql}{(sep.rstrip() if comments else sep) if i + 1 < num_sqls else ''}{comments}"
3853                    )
3854            else:
3855                result_sqls.append(f"{prefix}{sql}{comments}{sep if i + 1 < num_sqls else ''}")
3856
3857        if self.pretty and (not dynamic or self.too_wide(result_sqls)):
3858            if new_line:
3859                result_sqls.insert(0, "")
3860                result_sqls.append("")
3861            result_sql = "\n".join(s.rstrip() for s in result_sqls)
3862        else:
3863            result_sql = "".join(result_sqls)
3864
3865        return (
3866            self.indent(result_sql, skip_first=skip_first, skip_last=skip_last)
3867            if indent
3868            else result_sql
3869        )
3870
3871    def op_expressions(self, op: str, expression: exp.Expression, flat: bool = False) -> str:
3872        flat = flat or isinstance(expression.parent, exp.Properties)
3873        expressions_sql = self.expressions(expression, flat=flat)
3874        if flat:
3875            return f"{op} {expressions_sql}"
3876        return f"{self.seg(op)}{self.sep() if expressions_sql else ''}{expressions_sql}"
3877
3878    def naked_property(self, expression: exp.Property) -> str:
3879        property_name = exp.Properties.PROPERTY_TO_NAME.get(expression.__class__)
3880        if not property_name:
3881            self.unsupported(f"Unsupported property {expression.__class__.__name__}")
3882        return f"{property_name} {self.sql(expression, 'this')}"
3883
3884    def tag_sql(self, expression: exp.Tag) -> str:
3885        return f"{expression.args.get('prefix')}{self.sql(expression.this)}{expression.args.get('postfix')}"
3886
3887    def token_sql(self, token_type: TokenType) -> str:
3888        return self.TOKEN_MAPPING.get(token_type, token_type.name)
3889
3890    def userdefinedfunction_sql(self, expression: exp.UserDefinedFunction) -> str:
3891        this = self.sql(expression, "this")
3892        expressions = self.no_identify(self.expressions, expression)
3893        expressions = (
3894            self.wrap(expressions) if expression.args.get("wrapped") else f" {expressions}"
3895        )
3896        return f"{this}{expressions}" if expressions.strip() != "" else this
3897
3898    def joinhint_sql(self, expression: exp.JoinHint) -> str:
3899        this = self.sql(expression, "this")
3900        expressions = self.expressions(expression, flat=True)
3901        return f"{this}({expressions})"
3902
3903    def kwarg_sql(self, expression: exp.Kwarg) -> str:
3904        return self.binary(expression, "=>")
3905
3906    def when_sql(self, expression: exp.When) -> str:
3907        matched = "MATCHED" if expression.args["matched"] else "NOT MATCHED"
3908        source = " BY SOURCE" if self.MATCHED_BY_SOURCE and expression.args.get("source") else ""
3909        condition = self.sql(expression, "condition")
3910        condition = f" AND {condition}" if condition else ""
3911
3912        then_expression = expression.args.get("then")
3913        if isinstance(then_expression, exp.Insert):
3914            this = self.sql(then_expression, "this")
3915            this = f"INSERT {this}" if this else "INSERT"
3916            then = self.sql(then_expression, "expression")
3917            then = f"{this} VALUES {then}" if then else this
3918        elif isinstance(then_expression, exp.Update):
3919            if isinstance(then_expression.args.get("expressions"), exp.Star):
3920                then = f"UPDATE {self.sql(then_expression, 'expressions')}"
3921            else:
3922                then = f"UPDATE SET{self.sep()}{self.expressions(then_expression)}"
3923        else:
3924            then = self.sql(then_expression)
3925        return f"WHEN {matched}{source}{condition} THEN {then}"
3926
3927    def whens_sql(self, expression: exp.Whens) -> str:
3928        return self.expressions(expression, sep=" ", indent=False)
3929
3930    def merge_sql(self, expression: exp.Merge) -> str:
3931        table = expression.this
3932        table_alias = ""
3933
3934        hints = table.args.get("hints")
3935        if hints and table.alias and isinstance(hints[0], exp.WithTableHint):
3936            # T-SQL syntax is MERGE ... <target_table> [WITH (<merge_hint>)] [[AS] table_alias]
3937            table_alias = f" AS {self.sql(table.args['alias'].pop())}"
3938
3939        this = self.sql(table)
3940        using = f"USING {self.sql(expression, 'using')}"
3941        on = f"ON {self.sql(expression, 'on')}"
3942        whens = self.sql(expression, "whens")
3943
3944        returning = self.sql(expression, "returning")
3945        if returning:
3946            whens = f"{whens}{returning}"
3947
3948        sep = self.sep()
3949
3950        return self.prepend_ctes(
3951            expression,
3952            f"MERGE INTO {this}{table_alias}{sep}{using}{sep}{on}{sep}{whens}",
3953        )
3954
3955    @unsupported_args("format")
3956    def tochar_sql(self, expression: exp.ToChar) -> str:
3957        return self.sql(exp.cast(expression.this, exp.DataType.Type.TEXT))
3958
3959    def tonumber_sql(self, expression: exp.ToNumber) -> str:
3960        if not self.SUPPORTS_TO_NUMBER:
3961            self.unsupported("Unsupported TO_NUMBER function")
3962            return self.sql(exp.cast(expression.this, exp.DataType.Type.DOUBLE))
3963
3964        fmt = expression.args.get("format")
3965        if not fmt:
3966            self.unsupported("Conversion format is required for TO_NUMBER")
3967            return self.sql(exp.cast(expression.this, exp.DataType.Type.DOUBLE))
3968
3969        return self.func("TO_NUMBER", expression.this, fmt)
3970
3971    def dictproperty_sql(self, expression: exp.DictProperty) -> str:
3972        this = self.sql(expression, "this")
3973        kind = self.sql(expression, "kind")
3974        settings_sql = self.expressions(expression, key="settings", sep=" ")
3975        args = f"({self.sep('')}{settings_sql}{self.seg(')', sep='')}" if settings_sql else "()"
3976        return f"{this}({kind}{args})"
3977
3978    def dictrange_sql(self, expression: exp.DictRange) -> str:
3979        this = self.sql(expression, "this")
3980        max = self.sql(expression, "max")
3981        min = self.sql(expression, "min")
3982        return f"{this}(MIN {min} MAX {max})"
3983
3984    def dictsubproperty_sql(self, expression: exp.DictSubProperty) -> str:
3985        return f"{self.sql(expression, 'this')} {self.sql(expression, 'value')}"
3986
3987    def duplicatekeyproperty_sql(self, expression: exp.DuplicateKeyProperty) -> str:
3988        return f"DUPLICATE KEY ({self.expressions(expression, flat=True)})"
3989
3990    # https://docs.starrocks.io/docs/sql-reference/sql-statements/table_bucket_part_index/CREATE_TABLE/
3991    def uniquekeyproperty_sql(self, expression: exp.UniqueKeyProperty) -> str:
3992        return f"UNIQUE KEY ({self.expressions(expression, flat=True)})"
3993
3994    # https://docs.starrocks.io/docs/sql-reference/sql-statements/data-definition/CREATE_TABLE/#distribution_desc
3995    def distributedbyproperty_sql(self, expression: exp.DistributedByProperty) -> str:
3996        expressions = self.expressions(expression, flat=True)
3997        expressions = f" {self.wrap(expressions)}" if expressions else ""
3998        buckets = self.sql(expression, "buckets")
3999        kind = self.sql(expression, "kind")
4000        buckets = f" BUCKETS {buckets}" if buckets else ""
4001        order = self.sql(expression, "order")
4002        return f"DISTRIBUTED BY {kind}{expressions}{buckets}{order}"
4003
4004    def oncluster_sql(self, expression: exp.OnCluster) -> str:
4005        return ""
4006
4007    def clusteredbyproperty_sql(self, expression: exp.ClusteredByProperty) -> str:
4008        expressions = self.expressions(expression, key="expressions", flat=True)
4009        sorted_by = self.expressions(expression, key="sorted_by", flat=True)
4010        sorted_by = f" SORTED BY ({sorted_by})" if sorted_by else ""
4011        buckets = self.sql(expression, "buckets")
4012        return f"CLUSTERED BY ({expressions}){sorted_by} INTO {buckets} BUCKETS"
4013
4014    def anyvalue_sql(self, expression: exp.AnyValue) -> str:
4015        this = self.sql(expression, "this")
4016        having = self.sql(expression, "having")
4017
4018        if having:
4019            this = f"{this} HAVING {'MAX' if expression.args.get('max') else 'MIN'} {having}"
4020
4021        return self.func("ANY_VALUE", this)
4022
4023    def querytransform_sql(self, expression: exp.QueryTransform) -> str:
4024        transform = self.func("TRANSFORM", *expression.expressions)
4025        row_format_before = self.sql(expression, "row_format_before")
4026        row_format_before = f" {row_format_before}" if row_format_before else ""
4027        record_writer = self.sql(expression, "record_writer")
4028        record_writer = f" RECORDWRITER {record_writer}" if record_writer else ""
4029        using = f" USING {self.sql(expression, 'command_script')}"
4030        schema = self.sql(expression, "schema")
4031        schema = f" AS {schema}" if schema else ""
4032        row_format_after = self.sql(expression, "row_format_after")
4033        row_format_after = f" {row_format_after}" if row_format_after else ""
4034        record_reader = self.sql(expression, "record_reader")
4035        record_reader = f" RECORDREADER {record_reader}" if record_reader else ""
4036        return f"{transform}{row_format_before}{record_writer}{using}{schema}{row_format_after}{record_reader}"
4037
4038    def indexconstraintoption_sql(self, expression: exp.IndexConstraintOption) -> str:
4039        key_block_size = self.sql(expression, "key_block_size")
4040        if key_block_size:
4041            return f"KEY_BLOCK_SIZE = {key_block_size}"
4042
4043        using = self.sql(expression, "using")
4044        if using:
4045            return f"USING {using}"
4046
4047        parser = self.sql(expression, "parser")
4048        if parser:
4049            return f"WITH PARSER {parser}"
4050
4051        comment = self.sql(expression, "comment")
4052        if comment:
4053            return f"COMMENT {comment}"
4054
4055        visible = expression.args.get("visible")
4056        if visible is not None:
4057            return "VISIBLE" if visible else "INVISIBLE"
4058
4059        engine_attr = self.sql(expression, "engine_attr")
4060        if engine_attr:
4061            return f"ENGINE_ATTRIBUTE = {engine_attr}"
4062
4063        secondary_engine_attr = self.sql(expression, "secondary_engine_attr")
4064        if secondary_engine_attr:
4065            return f"SECONDARY_ENGINE_ATTRIBUTE = {secondary_engine_attr}"
4066
4067        self.unsupported("Unsupported index constraint option.")
4068        return ""
4069
4070    def checkcolumnconstraint_sql(self, expression: exp.CheckColumnConstraint) -> str:
4071        enforced = " ENFORCED" if expression.args.get("enforced") else ""
4072        return f"CHECK ({self.sql(expression, 'this')}){enforced}"
4073
4074    def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str:
4075        kind = self.sql(expression, "kind")
4076        kind = f"{kind} INDEX" if kind else "INDEX"
4077        this = self.sql(expression, "this")
4078        this = f" {this}" if this else ""
4079        index_type = self.sql(expression, "index_type")
4080        index_type = f" USING {index_type}" if index_type else ""
4081        expressions = self.expressions(expression, flat=True)
4082        expressions = f" ({expressions})" if expressions else ""
4083        options = self.expressions(expression, key="options", sep=" ")
4084        options = f" {options}" if options else ""
4085        return f"{kind}{this}{index_type}{expressions}{options}"
4086
4087    def nvl2_sql(self, expression: exp.Nvl2) -> str:
4088        if self.NVL2_SUPPORTED:
4089            return self.function_fallback_sql(expression)
4090
4091        case = exp.Case().when(
4092            expression.this.is_(exp.null()).not_(copy=False),
4093            expression.args["true"],
4094            copy=False,
4095        )
4096        else_cond = expression.args.get("false")
4097        if else_cond:
4098            case.else_(else_cond, copy=False)
4099
4100        return self.sql(case)
4101
4102    def comprehension_sql(self, expression: exp.Comprehension) -> str:
4103        this = self.sql(expression, "this")
4104        expr = self.sql(expression, "expression")
4105        iterator = self.sql(expression, "iterator")
4106        condition = self.sql(expression, "condition")
4107        condition = f" IF {condition}" if condition else ""
4108        return f"{this} FOR {expr} IN {iterator}{condition}"
4109
4110    def columnprefix_sql(self, expression: exp.ColumnPrefix) -> str:
4111        return f"{self.sql(expression, 'this')}({self.sql(expression, 'expression')})"
4112
4113    def opclass_sql(self, expression: exp.Opclass) -> str:
4114        return f"{self.sql(expression, 'this')} {self.sql(expression, 'expression')}"
4115
4116    def predict_sql(self, expression: exp.Predict) -> str:
4117        model = self.sql(expression, "this")
4118        model = f"MODEL {model}"
4119        table = self.sql(expression, "expression")
4120        table = f"TABLE {table}" if not isinstance(expression.expression, exp.Subquery) else table
4121        parameters = self.sql(expression, "params_struct")
4122        return self.func("PREDICT", model, table, parameters or None)
4123
4124    def forin_sql(self, expression: exp.ForIn) -> str:
4125        this = self.sql(expression, "this")
4126        expression_sql = self.sql(expression, "expression")
4127        return f"FOR {this} DO {expression_sql}"
4128
4129    def refresh_sql(self, expression: exp.Refresh) -> str:
4130        this = self.sql(expression, "this")
4131        table = "" if isinstance(expression.this, exp.Literal) else "TABLE "
4132        return f"REFRESH {table}{this}"
4133
4134    def toarray_sql(self, expression: exp.ToArray) -> str:
4135        arg = expression.this
4136        if not arg.type:
4137            from sqlglot.optimizer.annotate_types import annotate_types
4138
4139            arg = annotate_types(arg, dialect=self.dialect)
4140
4141        if arg.is_type(exp.DataType.Type.ARRAY):
4142            return self.sql(arg)
4143
4144        cond_for_null = arg.is_(exp.null())
4145        return self.sql(exp.func("IF", cond_for_null, exp.null(), exp.array(arg, copy=False)))
4146
4147    def tsordstotime_sql(self, expression: exp.TsOrDsToTime) -> str:
4148        this = expression.this
4149        time_format = self.format_time(expression)
4150
4151        if time_format:
4152            return self.sql(
4153                exp.cast(
4154                    exp.StrToTime(this=this, format=expression.args["format"]),
4155                    exp.DataType.Type.TIME,
4156                )
4157            )
4158
4159        if isinstance(this, exp.TsOrDsToTime) or this.is_type(exp.DataType.Type.TIME):
4160            return self.sql(this)
4161
4162        return self.sql(exp.cast(this, exp.DataType.Type.TIME))
4163
4164    def tsordstotimestamp_sql(self, expression: exp.TsOrDsToTimestamp) -> str:
4165        this = expression.this
4166        if isinstance(this, exp.TsOrDsToTimestamp) or this.is_type(exp.DataType.Type.TIMESTAMP):
4167            return self.sql(this)
4168
4169        return self.sql(exp.cast(this, exp.DataType.Type.TIMESTAMP, dialect=self.dialect))
4170
4171    def tsordstodatetime_sql(self, expression: exp.TsOrDsToDatetime) -> str:
4172        this = expression.this
4173        if isinstance(this, exp.TsOrDsToDatetime) or this.is_type(exp.DataType.Type.DATETIME):
4174            return self.sql(this)
4175
4176        return self.sql(exp.cast(this, exp.DataType.Type.DATETIME, dialect=self.dialect))
4177
4178    def tsordstodate_sql(self, expression: exp.TsOrDsToDate) -> str:
4179        this = expression.this
4180        time_format = self.format_time(expression)
4181
4182        if time_format and time_format not in (self.dialect.TIME_FORMAT, self.dialect.DATE_FORMAT):
4183            return self.sql(
4184                exp.cast(
4185                    exp.StrToTime(this=this, format=expression.args["format"]),
4186                    exp.DataType.Type.DATE,
4187                )
4188            )
4189
4190        if isinstance(this, exp.TsOrDsToDate) or this.is_type(exp.DataType.Type.DATE):
4191            return self.sql(this)
4192
4193        return self.sql(exp.cast(this, exp.DataType.Type.DATE))
4194
4195    def unixdate_sql(self, expression: exp.UnixDate) -> str:
4196        return self.sql(
4197            exp.func(
4198                "DATEDIFF",
4199                expression.this,
4200                exp.cast(exp.Literal.string("1970-01-01"), exp.DataType.Type.DATE),
4201                "day",
4202            )
4203        )
4204
4205    def lastday_sql(self, expression: exp.LastDay) -> str:
4206        if self.LAST_DAY_SUPPORTS_DATE_PART:
4207            return self.function_fallback_sql(expression)
4208
4209        unit = expression.text("unit")
4210        if unit and unit != "MONTH":
4211            self.unsupported("Date parts are not supported in LAST_DAY.")
4212
4213        return self.func("LAST_DAY", expression.this)
4214
4215    def dateadd_sql(self, expression: exp.DateAdd) -> str:
4216        from sqlglot.dialects.dialect import unit_to_str
4217
4218        return self.func(
4219            "DATE_ADD", expression.this, expression.expression, unit_to_str(expression)
4220        )
4221
4222    def arrayany_sql(self, expression: exp.ArrayAny) -> str:
4223        if self.CAN_IMPLEMENT_ARRAY_ANY:
4224            filtered = exp.ArrayFilter(this=expression.this, expression=expression.expression)
4225            filtered_not_empty = exp.ArraySize(this=filtered).neq(0)
4226            original_is_empty = exp.ArraySize(this=expression.this).eq(0)
4227            return self.sql(exp.paren(original_is_empty.or_(filtered_not_empty)))
4228
4229        from sqlglot.dialects import Dialect
4230
4231        # SQLGlot's executor supports ARRAY_ANY, so we don't wanna warn for the SQLGlot dialect
4232        if self.dialect.__class__ != Dialect:
4233            self.unsupported("ARRAY_ANY is unsupported")
4234
4235        return self.function_fallback_sql(expression)
4236
4237    def struct_sql(self, expression: exp.Struct) -> str:
4238        expression.set(
4239            "expressions",
4240            [
4241                exp.alias_(e.expression, e.name if e.this.is_string else e.this)
4242                if isinstance(e, exp.PropertyEQ)
4243                else e
4244                for e in expression.expressions
4245            ],
4246        )
4247
4248        return self.function_fallback_sql(expression)
4249
4250    def partitionrange_sql(self, expression: exp.PartitionRange) -> str:
4251        low = self.sql(expression, "this")
4252        high = self.sql(expression, "expression")
4253
4254        return f"{low} TO {high}"
4255
4256    def truncatetable_sql(self, expression: exp.TruncateTable) -> str:
4257        target = "DATABASE" if expression.args.get("is_database") else "TABLE"
4258        tables = f" {self.expressions(expression)}"
4259
4260        exists = " IF EXISTS" if expression.args.get("exists") else ""
4261
4262        on_cluster = self.sql(expression, "cluster")
4263        on_cluster = f" {on_cluster}" if on_cluster else ""
4264
4265        identity = self.sql(expression, "identity")
4266        identity = f" {identity} IDENTITY" if identity else ""
4267
4268        option = self.sql(expression, "option")
4269        option = f" {option}" if option else ""
4270
4271        partition = self.sql(expression, "partition")
4272        partition = f" {partition}" if partition else ""
4273
4274        return f"TRUNCATE {target}{exists}{tables}{on_cluster}{identity}{option}{partition}"
4275
4276    # This transpiles T-SQL's CONVERT function
4277    # https://learn.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?view=sql-server-ver16
4278    def convert_sql(self, expression: exp.Convert) -> str:
4279        to = expression.this
4280        value = expression.expression
4281        style = expression.args.get("style")
4282        safe = expression.args.get("safe")
4283        strict = expression.args.get("strict")
4284
4285        if not to or not value:
4286            return ""
4287
4288        # Retrieve length of datatype and override to default if not specified
4289        if not seq_get(to.expressions, 0) and to.this in self.PARAMETERIZABLE_TEXT_TYPES:
4290            to = exp.DataType.build(to.this, expressions=[exp.Literal.number(30)], nested=False)
4291
4292        transformed: t.Optional[exp.Expression] = None
4293        cast = exp.Cast if strict else exp.TryCast
4294
4295        # Check whether a conversion with format (T-SQL calls this 'style') is applicable
4296        if isinstance(style, exp.Literal) and style.is_int:
4297            from sqlglot.dialects.tsql import TSQL
4298
4299            style_value = style.name
4300            converted_style = TSQL.CONVERT_FORMAT_MAPPING.get(style_value)
4301            if not converted_style:
4302                self.unsupported(f"Unsupported T-SQL 'style' value: {style_value}")
4303
4304            fmt = exp.Literal.string(converted_style)
4305
4306            if to.this == exp.DataType.Type.DATE:
4307                transformed = exp.StrToDate(this=value, format=fmt)
4308            elif to.this in (exp.DataType.Type.DATETIME, exp.DataType.Type.DATETIME2):
4309                transformed = exp.StrToTime(this=value, format=fmt)
4310            elif to.this in self.PARAMETERIZABLE_TEXT_TYPES:
4311                transformed = cast(this=exp.TimeToStr(this=value, format=fmt), to=to, safe=safe)
4312            elif to.this == exp.DataType.Type.TEXT:
4313                transformed = exp.TimeToStr(this=value, format=fmt)
4314
4315        if not transformed:
4316            transformed = cast(this=value, to=to, safe=safe)
4317
4318        return self.sql(transformed)
4319
4320    def _jsonpathkey_sql(self, expression: exp.JSONPathKey) -> str:
4321        this = expression.this
4322        if isinstance(this, exp.JSONPathWildcard):
4323            this = self.json_path_part(this)
4324            return f".{this}" if this else ""
4325
4326        if exp.SAFE_IDENTIFIER_RE.match(this):
4327            return f".{this}"
4328
4329        this = self.json_path_part(this)
4330        return (
4331            f"[{this}]"
4332            if self._quote_json_path_key_using_brackets and self.JSON_PATH_BRACKETED_KEY_SUPPORTED
4333            else f".{this}"
4334        )
4335
4336    def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str:
4337        this = self.json_path_part(expression.this)
4338        return f"[{this}]" if this else ""
4339
4340    def _simplify_unless_literal(self, expression: E) -> E:
4341        if not isinstance(expression, exp.Literal):
4342            from sqlglot.optimizer.simplify import simplify
4343
4344            expression = simplify(expression, dialect=self.dialect)
4345
4346        return expression
4347
4348    def _embed_ignore_nulls(self, expression: exp.IgnoreNulls | exp.RespectNulls, text: str) -> str:
4349        this = expression.this
4350        if isinstance(this, self.RESPECT_IGNORE_NULLS_UNSUPPORTED_EXPRESSIONS):
4351            self.unsupported(
4352                f"RESPECT/IGNORE NULLS is not supported for {type(this).key} in {self.dialect.__class__.__name__}"
4353            )
4354            return self.sql(this)
4355
4356        if self.IGNORE_NULLS_IN_FUNC and not expression.meta.get("inline"):
4357            # The first modifier here will be the one closest to the AggFunc's arg
4358            mods = sorted(
4359                expression.find_all(exp.HavingMax, exp.Order, exp.Limit),
4360                key=lambda x: 0
4361                if isinstance(x, exp.HavingMax)
4362                else (1 if isinstance(x, exp.Order) else 2),
4363            )
4364
4365            if mods:
4366                mod = mods[0]
4367                this = expression.__class__(this=mod.this.copy())
4368                this.meta["inline"] = True
4369                mod.this.replace(this)
4370                return self.sql(expression.this)
4371
4372            agg_func = expression.find(exp.AggFunc)
4373
4374            if agg_func:
4375                agg_func_sql = self.sql(agg_func, comment=False)[:-1] + f" {text})"
4376                return self.maybe_comment(agg_func_sql, comments=agg_func.comments)
4377
4378        return f"{self.sql(expression, 'this')} {text}"
4379
4380    def _replace_line_breaks(self, string: str) -> str:
4381        """We don't want to extra indent line breaks so we temporarily replace them with sentinels."""
4382        if self.pretty:
4383            return string.replace("\n", self.SENTINEL_LINE_BREAK)
4384        return string
4385
4386    def copyparameter_sql(self, expression: exp.CopyParameter) -> str:
4387        option = self.sql(expression, "this")
4388
4389        if expression.expressions:
4390            upper = option.upper()
4391
4392            # Snowflake FILE_FORMAT options are separated by whitespace
4393            sep = " " if upper == "FILE_FORMAT" else ", "
4394
4395            # Databricks copy/format options do not set their list of values with EQ
4396            op = " " if upper in ("COPY_OPTIONS", "FORMAT_OPTIONS") else " = "
4397            values = self.expressions(expression, flat=True, sep=sep)
4398            return f"{option}{op}({values})"
4399
4400        value = self.sql(expression, "expression")
4401
4402        if not value:
4403            return option
4404
4405        op = " = " if self.COPY_PARAMS_EQ_REQUIRED else " "
4406
4407        return f"{option}{op}{value}"
4408
4409    def credentials_sql(self, expression: exp.Credentials) -> str:
4410        cred_expr = expression.args.get("credentials")
4411        if isinstance(cred_expr, exp.Literal):
4412            # Redshift case: CREDENTIALS <string>
4413            credentials = self.sql(expression, "credentials")
4414            credentials = f"CREDENTIALS {credentials}" if credentials else ""
4415        else:
4416            # Snowflake case: CREDENTIALS = (...)
4417            credentials = self.expressions(expression, key="credentials", flat=True, sep=" ")
4418            credentials = f"CREDENTIALS = ({credentials})" if cred_expr is not None else ""
4419
4420        storage = self.sql(expression, "storage")
4421        storage = f"STORAGE_INTEGRATION = {storage}" if storage else ""
4422
4423        encryption = self.expressions(expression, key="encryption", flat=True, sep=" ")
4424        encryption = f" ENCRYPTION = ({encryption})" if encryption else ""
4425
4426        iam_role = self.sql(expression, "iam_role")
4427        iam_role = f"IAM_ROLE {iam_role}" if iam_role else ""
4428
4429        region = self.sql(expression, "region")
4430        region = f" REGION {region}" if region else ""
4431
4432        return f"{credentials}{storage}{encryption}{iam_role}{region}"
4433
4434    def copy_sql(self, expression: exp.Copy) -> str:
4435        this = self.sql(expression, "this")
4436        this = f" INTO {this}" if self.COPY_HAS_INTO_KEYWORD else f" {this}"
4437
4438        credentials = self.sql(expression, "credentials")
4439        credentials = self.seg(credentials) if credentials else ""
4440        kind = self.seg("FROM" if expression.args.get("kind") else "TO")
4441        files = self.expressions(expression, key="files", flat=True)
4442
4443        sep = ", " if self.dialect.COPY_PARAMS_ARE_CSV else " "
4444        params = self.expressions(
4445            expression,
4446            key="params",
4447            sep=sep,
4448            new_line=True,
4449            skip_last=True,
4450            skip_first=True,
4451            indent=self.COPY_PARAMS_ARE_WRAPPED,
4452        )
4453
4454        if params:
4455            if self.COPY_PARAMS_ARE_WRAPPED:
4456                params = f" WITH ({params})"
4457            elif not self.pretty:
4458                params = f" {params}"
4459
4460        return f"COPY{this}{kind} {files}{credentials}{params}"
4461
4462    def semicolon_sql(self, expression: exp.Semicolon) -> str:
4463        return ""
4464
4465    def datadeletionproperty_sql(self, expression: exp.DataDeletionProperty) -> str:
4466        on_sql = "ON" if expression.args.get("on") else "OFF"
4467        filter_col: t.Optional[str] = self.sql(expression, "filter_column")
4468        filter_col = f"FILTER_COLUMN={filter_col}" if filter_col else None
4469        retention_period: t.Optional[str] = self.sql(expression, "retention_period")
4470        retention_period = f"RETENTION_PERIOD={retention_period}" if retention_period else None
4471
4472        if filter_col or retention_period:
4473            on_sql = self.func("ON", filter_col, retention_period)
4474
4475        return f"DATA_DELETION={on_sql}"
4476
4477    def maskingpolicycolumnconstraint_sql(
4478        self, expression: exp.MaskingPolicyColumnConstraint
4479    ) -> str:
4480        this = self.sql(expression, "this")
4481        expressions = self.expressions(expression, flat=True)
4482        expressions = f" USING ({expressions})" if expressions else ""
4483        return f"MASKING POLICY {this}{expressions}"
4484
4485    def gapfill_sql(self, expression: exp.GapFill) -> str:
4486        this = self.sql(expression, "this")
4487        this = f"TABLE {this}"
4488        return self.func("GAP_FILL", this, *[v for k, v in expression.args.items() if k != "this"])
4489
4490    def scope_resolution(self, rhs: str, scope_name: str) -> str:
4491        return self.func("SCOPE_RESOLUTION", scope_name or None, rhs)
4492
4493    def scoperesolution_sql(self, expression: exp.ScopeResolution) -> str:
4494        this = self.sql(expression, "this")
4495        expr = expression.expression
4496
4497        if isinstance(expr, exp.Func):
4498            # T-SQL's CLR functions are case sensitive
4499            expr = f"{self.sql(expr, 'this')}({self.format_args(*expr.expressions)})"
4500        else:
4501            expr = self.sql(expression, "expression")
4502
4503        return self.scope_resolution(expr, this)
4504
4505    def parsejson_sql(self, expression: exp.ParseJSON) -> str:
4506        if self.PARSE_JSON_NAME is None:
4507            return self.sql(expression.this)
4508
4509        return self.func(self.PARSE_JSON_NAME, expression.this, expression.expression)
4510
4511    def rand_sql(self, expression: exp.Rand) -> str:
4512        lower = self.sql(expression, "lower")
4513        upper = self.sql(expression, "upper")
4514
4515        if lower and upper:
4516            return f"({upper} - {lower}) * {self.func('RAND', expression.this)} + {lower}"
4517        return self.func("RAND", expression.this)
4518
4519    def changes_sql(self, expression: exp.Changes) -> str:
4520        information = self.sql(expression, "information")
4521        information = f"INFORMATION => {information}"
4522        at_before = self.sql(expression, "at_before")
4523        at_before = f"{self.seg('')}{at_before}" if at_before else ""
4524        end = self.sql(expression, "end")
4525        end = f"{self.seg('')}{end}" if end else ""
4526
4527        return f"CHANGES ({information}){at_before}{end}"
4528
4529    def pad_sql(self, expression: exp.Pad) -> str:
4530        prefix = "L" if expression.args.get("is_left") else "R"
4531
4532        fill_pattern = self.sql(expression, "fill_pattern") or None
4533        if not fill_pattern and self.PAD_FILL_PATTERN_IS_REQUIRED:
4534            fill_pattern = "' '"
4535
4536        return self.func(f"{prefix}PAD", expression.this, expression.expression, fill_pattern)
4537
4538    def summarize_sql(self, expression: exp.Summarize) -> str:
4539        table = " TABLE" if expression.args.get("table") else ""
4540        return f"SUMMARIZE{table} {self.sql(expression.this)}"
4541
4542    def explodinggenerateseries_sql(self, expression: exp.ExplodingGenerateSeries) -> str:
4543        generate_series = exp.GenerateSeries(**expression.args)
4544
4545        parent = expression.parent
4546        if isinstance(parent, (exp.Alias, exp.TableAlias)):
4547            parent = parent.parent
4548
4549        if self.SUPPORTS_EXPLODING_PROJECTIONS and not isinstance(parent, (exp.Table, exp.Unnest)):
4550            return self.sql(exp.Unnest(expressions=[generate_series]))
4551
4552        if isinstance(parent, exp.Select):
4553            self.unsupported("GenerateSeries projection unnesting is not supported.")
4554
4555        return self.sql(generate_series)
4556
4557    def arrayconcat_sql(self, expression: exp.ArrayConcat, name: str = "ARRAY_CONCAT") -> str:
4558        exprs = expression.expressions
4559        if not self.ARRAY_CONCAT_IS_VAR_LEN:
4560            rhs = reduce(lambda x, y: exp.ArrayConcat(this=x, expressions=[y]), exprs)
4561        else:
4562            rhs = self.expressions(expression)
4563
4564        return self.func(name, expression.this, rhs or None)
4565
4566    def converttimezone_sql(self, expression: exp.ConvertTimezone) -> str:
4567        if self.SUPPORTS_CONVERT_TIMEZONE:
4568            return self.function_fallback_sql(expression)
4569
4570        source_tz = expression.args.get("source_tz")
4571        target_tz = expression.args.get("target_tz")
4572        timestamp = expression.args.get("timestamp")
4573
4574        if source_tz and timestamp:
4575            timestamp = exp.AtTimeZone(
4576                this=exp.cast(timestamp, exp.DataType.Type.TIMESTAMPNTZ), zone=source_tz
4577            )
4578
4579        expr = exp.AtTimeZone(this=timestamp, zone=target_tz)
4580
4581        return self.sql(expr)
4582
4583    def json_sql(self, expression: exp.JSON) -> str:
4584        this = self.sql(expression, "this")
4585        this = f" {this}" if this else ""
4586
4587        _with = expression.args.get("with")
4588
4589        if _with is None:
4590            with_sql = ""
4591        elif not _with:
4592            with_sql = " WITHOUT"
4593        else:
4594            with_sql = " WITH"
4595
4596        unique_sql = " UNIQUE KEYS" if expression.args.get("unique") else ""
4597
4598        return f"JSON{this}{with_sql}{unique_sql}"
4599
4600    def jsonvalue_sql(self, expression: exp.JSONValue) -> str:
4601        def _generate_on_options(arg: t.Any) -> str:
4602            return arg if isinstance(arg, str) else f"DEFAULT {self.sql(arg)}"
4603
4604        path = self.sql(expression, "path")
4605        returning = self.sql(expression, "returning")
4606        returning = f" RETURNING {returning}" if returning else ""
4607
4608        on_condition = self.sql(expression, "on_condition")
4609        on_condition = f" {on_condition}" if on_condition else ""
4610
4611        return self.func("JSON_VALUE", expression.this, f"{path}{returning}{on_condition}")
4612
4613    def conditionalinsert_sql(self, expression: exp.ConditionalInsert) -> str:
4614        else_ = "ELSE " if expression.args.get("else_") else ""
4615        condition = self.sql(expression, "expression")
4616        condition = f"WHEN {condition} THEN " if condition else else_
4617        insert = self.sql(expression, "this")[len("INSERT") :].strip()
4618        return f"{condition}{insert}"
4619
4620    def multitableinserts_sql(self, expression: exp.MultitableInserts) -> str:
4621        kind = self.sql(expression, "kind")
4622        expressions = self.seg(self.expressions(expression, sep=" "))
4623        res = f"INSERT {kind}{expressions}{self.seg(self.sql(expression, 'source'))}"
4624        return res
4625
4626    def oncondition_sql(self, expression: exp.OnCondition) -> str:
4627        # Static options like "NULL ON ERROR" are stored as strings, in contrast to "DEFAULT <expr> ON ERROR"
4628        empty = expression.args.get("empty")
4629        empty = (
4630            f"DEFAULT {empty} ON EMPTY"
4631            if isinstance(empty, exp.Expression)
4632            else self.sql(expression, "empty")
4633        )
4634
4635        error = expression.args.get("error")
4636        error = (
4637            f"DEFAULT {error} ON ERROR"
4638            if isinstance(error, exp.Expression)
4639            else self.sql(expression, "error")
4640        )
4641
4642        if error and empty:
4643            error = (
4644                f"{empty} {error}"
4645                if self.dialect.ON_CONDITION_EMPTY_BEFORE_ERROR
4646                else f"{error} {empty}"
4647            )
4648            empty = ""
4649
4650        null = self.sql(expression, "null")
4651
4652        return f"{empty}{error}{null}"
4653
4654    def jsonextractquote_sql(self, expression: exp.JSONExtractQuote) -> str:
4655        scalar = " ON SCALAR STRING" if expression.args.get("scalar") else ""
4656        return f"{self.sql(expression, 'option')} QUOTES{scalar}"
4657
4658    def jsonexists_sql(self, expression: exp.JSONExists) -> str:
4659        this = self.sql(expression, "this")
4660        path = self.sql(expression, "path")
4661
4662        passing = self.expressions(expression, "passing")
4663        passing = f" PASSING {passing}" if passing else ""
4664
4665        on_condition = self.sql(expression, "on_condition")
4666        on_condition = f" {on_condition}" if on_condition else ""
4667
4668        path = f"{path}{passing}{on_condition}"
4669
4670        return self.func("JSON_EXISTS", this, path)
4671
4672    def arrayagg_sql(self, expression: exp.ArrayAgg) -> str:
4673        array_agg = self.function_fallback_sql(expression)
4674
4675        # Add a NULL FILTER on the column to mimic the results going from a dialect that excludes nulls
4676        # on ARRAY_AGG (e.g Spark) to one that doesn't (e.g. DuckDB)
4677        if self.dialect.ARRAY_AGG_INCLUDES_NULLS and expression.args.get("nulls_excluded"):
4678            parent = expression.parent
4679            if isinstance(parent, exp.Filter):
4680                parent_cond = parent.expression.this
4681                parent_cond.replace(parent_cond.and_(expression.this.is_(exp.null()).not_()))
4682            else:
4683                this = expression.this
4684                # Do not add the filter if the input is not a column (e.g. literal, struct etc)
4685                if this.find(exp.Column):
4686                    # DISTINCT is already present in the agg function, do not propagate it to FILTER as well
4687                    this_sql = (
4688                        self.expressions(this)
4689                        if isinstance(this, exp.Distinct)
4690                        else self.sql(expression, "this")
4691                    )
4692
4693                    array_agg = f"{array_agg} FILTER(WHERE {this_sql} IS NOT NULL)"
4694
4695        return array_agg
4696
4697    def apply_sql(self, expression: exp.Apply) -> str:
4698        this = self.sql(expression, "this")
4699        expr = self.sql(expression, "expression")
4700
4701        return f"{this} APPLY({expr})"
4702
4703    def grant_sql(self, expression: exp.Grant) -> str:
4704        privileges_sql = self.expressions(expression, key="privileges", flat=True)
4705
4706        kind = self.sql(expression, "kind")
4707        kind = f" {kind}" if kind else ""
4708
4709        securable = self.sql(expression, "securable")
4710        securable = f" {securable}" if securable else ""
4711
4712        principals = self.expressions(expression, key="principals", flat=True)
4713
4714        grant_option = " WITH GRANT OPTION" if expression.args.get("grant_option") else ""
4715
4716        return f"GRANT {privileges_sql} ON{kind}{securable} TO {principals}{grant_option}"
4717
4718    def grantprivilege_sql(self, expression: exp.GrantPrivilege):
4719        this = self.sql(expression, "this")
4720        columns = self.expressions(expression, flat=True)
4721        columns = f"({columns})" if columns else ""
4722
4723        return f"{this}{columns}"
4724
4725    def grantprincipal_sql(self, expression: exp.GrantPrincipal):
4726        this = self.sql(expression, "this")
4727
4728        kind = self.sql(expression, "kind")
4729        kind = f"{kind} " if kind else ""
4730
4731        return f"{kind}{this}"
4732
4733    def columns_sql(self, expression: exp.Columns):
4734        func = self.function_fallback_sql(expression)
4735        if expression.args.get("unpack"):
4736            func = f"*{func}"
4737
4738        return func
4739
4740    def overlay_sql(self, expression: exp.Overlay):
4741        this = self.sql(expression, "this")
4742        expr = self.sql(expression, "expression")
4743        from_sql = self.sql(expression, "from")
4744        for_sql = self.sql(expression, "for")
4745        for_sql = f" FOR {for_sql}" if for_sql else ""
4746
4747        return f"OVERLAY({this} PLACING {expr} FROM {from_sql}{for_sql})"
4748
4749    @unsupported_args("format")
4750    def todouble_sql(self, expression: exp.ToDouble) -> str:
4751        return self.sql(exp.cast(expression.this, exp.DataType.Type.DOUBLE))
4752
4753    def string_sql(self, expression: exp.String) -> str:
4754        this = expression.this
4755        zone = expression.args.get("zone")
4756
4757        if zone:
4758            # This is a BigQuery specific argument for STRING(<timestamp_expr>, <time_zone>)
4759            # BigQuery stores timestamps internally as UTC, so ConvertTimezone is used with UTC
4760            # set for source_tz to transpile the time conversion before the STRING cast
4761            this = exp.ConvertTimezone(
4762                source_tz=exp.Literal.string("UTC"), target_tz=zone, timestamp=this
4763            )
4764
4765        return self.sql(exp.cast(this, exp.DataType.Type.VARCHAR))
4766
4767    def median_sql(self, expression: exp.Median):
4768        if not self.SUPPORTS_MEDIAN:
4769            return self.sql(
4770                exp.PercentileCont(this=expression.this, expression=exp.Literal.number(0.5))
4771            )
4772
4773        return self.function_fallback_sql(expression)
4774
4775    def overflowtruncatebehavior_sql(self, expression: exp.OverflowTruncateBehavior) -> str:
4776        filler = self.sql(expression, "this")
4777        filler = f" {filler}" if filler else ""
4778        with_count = "WITH COUNT" if expression.args.get("with_count") else "WITHOUT COUNT"
4779        return f"TRUNCATE{filler} {with_count}"
4780
4781    def unixseconds_sql(self, expression: exp.UnixSeconds) -> str:
4782        if self.SUPPORTS_UNIX_SECONDS:
4783            return self.function_fallback_sql(expression)
4784
4785        start_ts = exp.cast(
4786            exp.Literal.string("1970-01-01 00:00:00+00"), to=exp.DataType.Type.TIMESTAMPTZ
4787        )
4788
4789        return self.sql(
4790            exp.TimestampDiff(this=expression.this, expression=start_ts, unit=exp.var("SECONDS"))
4791        )
4792
4793    def arraysize_sql(self, expression: exp.ArraySize) -> str:
4794        dim = expression.expression
4795
4796        # For dialects that don't support the dimension arg, we can safely transpile it's default value (1st dimension)
4797        if dim and self.ARRAY_SIZE_DIM_REQUIRED is None:
4798            if not (dim.is_int and dim.name == "1"):
4799                self.unsupported("Cannot transpile dimension argument for ARRAY_LENGTH")
4800            dim = None
4801
4802        # If dimension is required but not specified, default initialize it
4803        if self.ARRAY_SIZE_DIM_REQUIRED and not dim:
4804            dim = exp.Literal.number(1)
4805
4806        return self.func(self.ARRAY_SIZE_NAME, expression.this, dim)
4807
4808    def attach_sql(self, expression: exp.Attach) -> str:
4809        this = self.sql(expression, "this")
4810        exists_sql = " IF NOT EXISTS" if expression.args.get("exists") else ""
4811        expressions = self.expressions(expression)
4812        expressions = f" ({expressions})" if expressions else ""
4813
4814        return f"ATTACH{exists_sql} {this}{expressions}"
4815
4816    def detach_sql(self, expression: exp.Detach) -> str:
4817        this = self.sql(expression, "this")
4818        # the DATABASE keyword is required if IF EXISTS is set
4819        # without it, DuckDB throws an error: Parser Error: syntax error at or near "exists" (Line Number: 1)
4820        # ref: https://duckdb.org/docs/stable/sql/statements/attach.html#detach-syntax
4821        exists_sql = " DATABASE IF EXISTS" if expression.args.get("exists") else ""
4822
4823        return f"DETACH{exists_sql} {this}"
4824
4825    def attachoption_sql(self, expression: exp.AttachOption) -> str:
4826        this = self.sql(expression, "this")
4827        value = self.sql(expression, "expression")
4828        value = f" {value}" if value else ""
4829        return f"{this}{value}"
4830
4831    def featuresattime_sql(self, expression: exp.FeaturesAtTime) -> str:
4832        this_sql = self.sql(expression, "this")
4833        if isinstance(expression.this, exp.Table):
4834            this_sql = f"TABLE {this_sql}"
4835
4836        return self.func(
4837            "FEATURES_AT_TIME",
4838            this_sql,
4839            expression.args.get("time"),
4840            expression.args.get("num_rows"),
4841            expression.args.get("ignore_feature_nulls"),
4842        )
4843
4844    def watermarkcolumnconstraint_sql(self, expression: exp.WatermarkColumnConstraint) -> str:
4845        return (
4846            f"WATERMARK FOR {self.sql(expression, 'this')} AS {self.sql(expression, 'expression')}"
4847        )
4848
4849    def encodeproperty_sql(self, expression: exp.EncodeProperty) -> str:
4850        encode = "KEY ENCODE" if expression.args.get("key") else "ENCODE"
4851        encode = f"{encode} {self.sql(expression, 'this')}"
4852
4853        properties = expression.args.get("properties")
4854        if properties:
4855            encode = f"{encode} {self.properties(properties)}"
4856
4857        return encode
4858
4859    def includeproperty_sql(self, expression: exp.IncludeProperty) -> str:
4860        this = self.sql(expression, "this")
4861        include = f"INCLUDE {this}"
4862
4863        column_def = self.sql(expression, "column_def")
4864        if column_def:
4865            include = f"{include} {column_def}"
4866
4867        alias = self.sql(expression, "alias")
4868        if alias:
4869            include = f"{include} AS {alias}"
4870
4871        return include
4872
4873    def xmlelement_sql(self, expression: exp.XMLElement) -> str:
4874        name = f"NAME {self.sql(expression, 'this')}"
4875        return self.func("XMLELEMENT", name, *expression.expressions)
4876
4877    def xmlkeyvalueoption_sql(self, expression: exp.XMLKeyValueOption) -> str:
4878        this = self.sql(expression, "this")
4879        expr = self.sql(expression, "expression")
4880        expr = f"({expr})" if expr else ""
4881        return f"{this}{expr}"
4882
4883    def partitionbyrangeproperty_sql(self, expression: exp.PartitionByRangeProperty) -> str:
4884        partitions = self.expressions(expression, "partition_expressions")
4885        create = self.expressions(expression, "create_expressions")
4886        return f"PARTITION BY RANGE {self.wrap(partitions)} {self.wrap(create)}"
4887
4888    def partitionbyrangepropertydynamic_sql(
4889        self, expression: exp.PartitionByRangePropertyDynamic
4890    ) -> str:
4891        start = self.sql(expression, "start")
4892        end = self.sql(expression, "end")
4893
4894        every = expression.args["every"]
4895        if isinstance(every, exp.Interval) and every.this.is_string:
4896            every.this.replace(exp.Literal.number(every.name))
4897
4898        return f"START {self.wrap(start)} END {self.wrap(end)} EVERY {self.wrap(self.sql(every))}"
4899
4900    def unpivotcolumns_sql(self, expression: exp.UnpivotColumns) -> str:
4901        name = self.sql(expression, "this")
4902        values = self.expressions(expression, flat=True)
4903
4904        return f"NAME {name} VALUE {values}"
4905
4906    def analyzesample_sql(self, expression: exp.AnalyzeSample) -> str:
4907        kind = self.sql(expression, "kind")
4908        sample = self.sql(expression, "sample")
4909        return f"SAMPLE {sample} {kind}"
4910
4911    def analyzestatistics_sql(self, expression: exp.AnalyzeStatistics) -> str:
4912        kind = self.sql(expression, "kind")
4913        option = self.sql(expression, "option")
4914        option = f" {option}" if option else ""
4915        this = self.sql(expression, "this")
4916        this = f" {this}" if this else ""
4917        columns = self.expressions(expression)
4918        columns = f" {columns}" if columns else ""
4919        return f"{kind}{option} STATISTICS{this}{columns}"
4920
4921    def analyzehistogram_sql(self, expression: exp.AnalyzeHistogram) -> str:
4922        this = self.sql(expression, "this")
4923        columns = self.expressions(expression)
4924        inner_expression = self.sql(expression, "expression")
4925        inner_expression = f" {inner_expression}" if inner_expression else ""
4926        update_options = self.sql(expression, "update_options")
4927        update_options = f" {update_options} UPDATE" if update_options else ""
4928        return f"{this} HISTOGRAM ON {columns}{inner_expression}{update_options}"
4929
4930    def analyzedelete_sql(self, expression: exp.AnalyzeDelete) -> str:
4931        kind = self.sql(expression, "kind")
4932        kind = f" {kind}" if kind else ""
4933        return f"DELETE{kind} STATISTICS"
4934
4935    def analyzelistchainedrows_sql(self, expression: exp.AnalyzeListChainedRows) -> str:
4936        inner_expression = self.sql(expression, "expression")
4937        return f"LIST CHAINED ROWS{inner_expression}"
4938
4939    def analyzevalidate_sql(self, expression: exp.AnalyzeValidate) -> str:
4940        kind = self.sql(expression, "kind")
4941        this = self.sql(expression, "this")
4942        this = f" {this}" if this else ""
4943        inner_expression = self.sql(expression, "expression")
4944        return f"VALIDATE {kind}{this}{inner_expression}"
4945
4946    def analyze_sql(self, expression: exp.Analyze) -> str:
4947        options = self.expressions(expression, key="options", sep=" ")
4948        options = f" {options}" if options else ""
4949        kind = self.sql(expression, "kind")
4950        kind = f" {kind}" if kind else ""
4951        this = self.sql(expression, "this")
4952        this = f" {this}" if this else ""
4953        mode = self.sql(expression, "mode")
4954        mode = f" {mode}" if mode else ""
4955        properties = self.sql(expression, "properties")
4956        properties = f" {properties}" if properties else ""
4957        partition = self.sql(expression, "partition")
4958        partition = f" {partition}" if partition else ""
4959        inner_expression = self.sql(expression, "expression")
4960        inner_expression = f" {inner_expression}" if inner_expression else ""
4961        return f"ANALYZE{options}{kind}{this}{partition}{mode}{inner_expression}{properties}"
4962
4963    def xmltable_sql(self, expression: exp.XMLTable) -> str:
4964        this = self.sql(expression, "this")
4965        namespaces = self.expressions(expression, key="namespaces")
4966        namespaces = f"XMLNAMESPACES({namespaces}), " if namespaces else ""
4967        passing = self.expressions(expression, key="passing")
4968        passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else ""
4969        columns = self.expressions(expression, key="columns")
4970        columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else ""
4971        by_ref = f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else ""
4972        return f"XMLTABLE({self.sep('')}{self.indent(namespaces + this + passing + by_ref + columns)}{self.seg(')', sep='')}"
4973
4974    def xmlnamespace_sql(self, expression: exp.XMLNamespace) -> str:
4975        this = self.sql(expression, "this")
4976        return this if isinstance(expression.this, exp.Alias) else f"DEFAULT {this}"
4977
4978    def export_sql(self, expression: exp.Export) -> str:
4979        this = self.sql(expression, "this")
4980        connection = self.sql(expression, "connection")
4981        connection = f"WITH CONNECTION {connection} " if connection else ""
4982        options = self.sql(expression, "options")
4983        return f"EXPORT DATA {connection}{options} AS {this}"
4984
4985    def declare_sql(self, expression: exp.Declare) -> str:
4986        return f"DECLARE {self.expressions(expression, flat=True)}"
4987
4988    def declareitem_sql(self, expression: exp.DeclareItem) -> str:
4989        variable = self.sql(expression, "this")
4990        default = self.sql(expression, "default")
4991        default = f" = {default}" if default else ""
4992
4993        kind = self.sql(expression, "kind")
4994        if isinstance(expression.args.get("kind"), exp.Schema):
4995            kind = f"TABLE {kind}"
4996
4997        return f"{variable} AS {kind}{default}"
4998
4999    def recursivewithsearch_sql(self, expression: exp.RecursiveWithSearch) -> str:
5000        kind = self.sql(expression, "kind")
5001        this = self.sql(expression, "this")
5002        set = self.sql(expression, "expression")
5003        using = self.sql(expression, "using")
5004        using = f" USING {using}" if using else ""
5005
5006        kind_sql = kind if kind == "CYCLE" else f"SEARCH {kind} FIRST BY"
5007
5008        return f"{kind_sql} {this} SET {set}{using}"
5009
5010    def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str:
5011        params = self.expressions(expression, key="params", flat=True)
5012        return self.func(expression.name, *expression.expressions) + f"({params})"
5013
5014    def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str:
5015        return self.func(expression.name, *expression.expressions)
5016
5017    def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str:
5018        return self.anonymousaggfunc_sql(expression)
5019
5020    def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str:
5021        return self.parameterizedagg_sql(expression)
5022
5023    def show_sql(self, expression: exp.Show) -> str:
5024        self.unsupported("Unsupported SHOW statement")
5025        return ""
5026
5027    def get_put_sql(self, expression: exp.Put | exp.Get) -> str:
5028        # Snowflake GET/PUT statements:
5029        #   PUT <file> <internalStage> <properties>
5030        #   GET <internalStage> <file> <properties>
5031        props = expression.args.get("properties")
5032        props_sql = self.properties(props, prefix=" ", sep=" ", wrapped=False) if props else ""
5033        this = self.sql(expression, "this")
5034        target = self.sql(expression, "target")
5035
5036        if isinstance(expression, exp.Put):
5037            return f"PUT {this} {target}{props_sql}"
5038        else:
5039            return f"GET {target} {this}{props_sql}"
5040
5041    def translatecharacters_sql(self, expression: exp.TranslateCharacters):
5042        this = self.sql(expression, "this")
5043        expr = self.sql(expression, "expression")
5044        with_error = " WITH ERROR" if expression.args.get("with_error") else ""
5045        return f"TRANSLATE({this} USING {expr}{with_error})"
5046
5047    def decodecase_sql(self, expression: exp.DecodeCase) -> str:
5048        if self.SUPPORTS_DECODE_CASE:
5049            return self.func("DECODE", *expression.expressions)
5050
5051        expression, *expressions = expression.expressions
5052
5053        ifs = []
5054        for search, result in zip(expressions[::2], expressions[1::2]):
5055            if isinstance(search, exp.Literal):
5056                ifs.append(exp.If(this=expression.eq(search), true=result))
5057            elif isinstance(search, exp.Null):
5058                ifs.append(exp.If(this=expression.is_(exp.Null()), true=result))
5059            else:
5060                if isinstance(search, exp.Binary):
5061                    search = exp.paren(search)
5062
5063                cond = exp.or_(
5064                    expression.eq(search),
5065                    exp.and_(expression.is_(exp.Null()), search.is_(exp.Null()), copy=False),
5066                    copy=False,
5067                )
5068                ifs.append(exp.If(this=cond, true=result))
5069
5070        case = exp.Case(ifs=ifs, default=expressions[-1] if len(expressions) % 2 == 1 else None)
5071        return self.sql(case)
5072
5073    def semanticview_sql(self, expression: exp.SemanticView) -> str:
5074        this = self.sql(expression, "this")
5075        this = self.seg(this, sep="")
5076        dimensions = self.expressions(
5077            expression, "dimensions", dynamic=True, skip_first=True, skip_last=True
5078        )
5079        dimensions = self.seg(f"DIMENSIONS {dimensions}") if dimensions else ""
5080        metrics = self.expressions(
5081            expression, "metrics", dynamic=True, skip_first=True, skip_last=True
5082        )
5083        metrics = self.seg(f"METRICS {metrics}") if metrics else ""
5084        where = self.sql(expression, "where")
5085        where = self.seg(f"WHERE {where}") if where else ""
5086        return f"SEMANTIC_VIEW({self.indent(this + metrics + dimensions + where)}{self.seg(')', sep='')}"